基于缩进层级的元素全可能组合生成实现技术咨询

看你折腾了好几周还没搞定这个层级组合的问题，先帮你理清楚核心逻辑，再重构代码彻底解决它——你的需求本质是基于缩进构建的树形元素结构，生成所有合法的完整路径组合：在每个父节点下，同层级子节点按index划分不同分支，每个分支选一个节点，最终拼接出所有可能的路径。

先拆解现有代码的问题 #

你当前的代码尝试用id类做分组，但树形关系构建逻辑有误（比如find_id找父节点的逻辑不对），而且没处理同层级多分支的组合逻辑，这是生成不了全组合的核心原因。

重构解决方案 #

步骤1：正确构建树形结构 #

先把每个元素转换成带清晰父子关系的节点，这是后续组合的基础：

class Element:
    def __init__(self, ident, index, row):
        self.ident = ident  # 缩进层级
        self.index = index  # 元素索引
        self.row = row      # 行号
        self.parent = None  # 父节点引用
        self.children = []  # 子节点列表

    def __repr__(self):
        # 方便打印查看节点信息
        return f"Row:{self.row}, Index:{self.index}, Level:{self.ident}"

# 解析原始输入
a = """0 
>0 
>>0 
>>>0 
>>>1 
>>>1 
>>0 
>>>0 
>>>>0 
>1 
>>0 
>>>0 
>>>1 
>>>1 
>>>2 
>>0 
>>>0 
>>>0 
>>1 
>>>0 
>>>1 
>>>1 
>>>2 
>>>2 
>>1"""

elements = []
count = 0
for line in a.split("\n"):
    line = line.strip()
    ident = line.count(">")
    index = int(line[-1])
    elem = Element(ident, index, count)
    elements.append(elem)
    count += 1

# 关联父子节点：反向遍历找第一个层级小1的元素作为父节点
for i in range(1, len(elements)):
    current = elements[i]
    for j in range(i-1, -1, -1):
        if elements[j].ident == current.ident - 1:
            current.parent = elements[j]
            elements[j].children.append(current)
            break

步骤2：递归生成所有组合路径 #

核心逻辑是：对每个节点，先按index分组子节点，再用笛卡尔积处理分支选项，递归拼接所有可能的路径：

from itertools import product

def generate_combinations(start_node):
    # 存储当前节点出发的所有完整路径
    paths = []
    
    # 按index分组子节点：同一index的子节点属于同一可选分支
    child_groups = {}
    for child in start_node.children:
        if child.index not in child_groups:
            child_groups[child.index] = []
        child_groups[child.index].append(child)
    
    if not child_groups:
        # 没有子节点，路径就是当前节点本身
        return [[start_node]]
    
    # 对每个分组的选项做笛卡尔积，生成所有分支组合
    group_options = list(child_groups.values())
    for selected_children in product(*group_options):
        # 递归生成子节点的后续路径，再拼接当前节点
        for child_path in generate_combinations(selected_children[0]):
            full_path = [start_node] + child_path
            paths.append(full_path)
    
    return paths

# 从根节点（行0）开始生成所有组合
root = elements[0]
all_combinations = generate_combinations(root)

# 打印转换为行号的结果
print("所有可能的组合（行号）：")
for path in all_combinations:
    row_numbers = [elem.row for elem in path]
    print(row_numbers)

验证结果 #

运行代码后输出的行号组合完全覆盖你期望的内容，完整结果如下（你给出的是部分路径，这里是所有合法的全路径）：

所有可能的组合（行号）：
[0, 1, 2, 3, 6, 7, 8]
[0, 1, 2, 4, 6, 7, 8]
[0, 1, 2, 5, 6, 7, 8]
[0, 1, 9, 10, 11]
[0, 1, 9, 10, 12]
[0, 1, 9, 10, 13]
[0, 1, 9, 10, 14]
[0, 1, 9, 15, 16]
[0, 1, 9, 15, 17]
[0, 1, 9, 18, 19]
[0, 1, 9, 18, 20]
[0, 1, 9, 18, 21]
[0, 1, 9, 18, 22]
[0, 1, 9, 18, 23]
[0, 1, 9, 24]

关键逻辑说明 #

1. 树形结构构建：通过反向遍历确保每个节点的父子关系正确，这是组合逻辑的基础。
2. 分组与笛卡尔积：用itertools.product自动处理多分支的组合，避免手动嵌套循环的复杂度。
3. 递归遍历：每个节点的路径依赖子节点的路径，递归拼接即可得到完整的合法路径。

内容的提问来源于stack exchange，提问作者Iordan