python中任意长度嵌套字典的一些组合

Question

我有一个游戏树，我有任意数量的可能动作，我的对手有任意顺序的动作。 我想了解所有“我可以做的动作集”和相应的信息。 在这个例子中，我缩小了我的问题范围。 每个动作我最多可以选择 2 个动作（“1”或“2”）。 我的对手最多可以选择 2 个动作（'a' 或 'b'）。 在这个例子中，有 5 种可能的“我可以做的动作”。 我如何以一种也适用于更大的游戏树的方式产生这个结果？

input = {'1': {'a': {'1': {'a': 'some_info_1'},
                     '2': {'a': 'some_info_2'}},                          
               'b': {'1': {'a': {'1': {'a': 'some_info_3'},
                                 '2': {'a': 'some_info_4'}}
                          }
                    },
              },
         '2': {'a': 'some_info_5'}
        }


output = {
    1: {'1': {'a': {'1': {'a': 'some_info_1'}},                          
              'b': {'1': {'a': {'1': {'a': 'some_info_3'}}}}}},
    2: {'1': {'a': {'2': {'a': 'some_info_2'}},                          
              'b': {'1': {'a': {'1': {'a': 'some_info_3'}}}}}},
    3: {'1': {'a': {'1': {'a': 'some_info_1'}},                          
              'b': {'1': {'a': {'2': {'a': 'some_info_4'}}}}}},                  
    4: {'1': {'a': {'2': {'a': 'some_info_2'}},                          
              'b': {'1': {'a': {'2': {'a': 'some_info_4'}}}}}},
    5: {'2': {'a': 'some_info_5'}}
}

我在这个网站和其他网站上搜索了答案。 该线程接近： Combination of nested dictionaries with arbitrary lengths in python

我还尝试for loops 、 itertools和cartesian products 。 但我无法让它工作。 真令人沮丧。 我希望有人能帮帮忙。

Answer 1

我对您如何对 output 集进行分组感到困惑，尤其是输出 [2] 和输出 [4]，但看起来您想实施某种形式的深度优先搜索，然后根据移动进行分组：

class state_node():

    def __init__(self, states, move, prev_moves = []):
        self.states = states
        self.prev_moves = prev_moves
        self.move = move
        
    def generate_next_moves(self):
        current_state = self.states
        
        for move in self.prev_moves:
            current_state = current_state[move]
            
        next_states = current_state[self.move]
        
        if isinstance(next_states, dict):
            return [state_node(self.states, next_move, self.prev_moves + [self.move]) for next_move in next_states]
        
        else:
            return None
        
    def __repr__(self):
        all_moves = self.prev_moves + [self.move]
        
        output_str = '['
        
        for move in all_moves:
            output_str += f"'{move}', "
            
        output_str = output_str[0:-2] + ']'
        
        return output_str
    
    def __eq__(self, other):
        
        return self.prev_moves == other.prev_moves and self.move == other.move

class state_tree():
    
    def __init__(self, states):
        
        self.states = states
        
        self.visited = []
        
        self.end_nodes = []
        
    def depth_first_search(self):
        
        self.unvisited = [state_node(self.states, move) for move in self.states if state_node(self.states, move) not in self.visited]
        
        while len(self.unvisited) > 0:
            target_node = self.unvisited.pop(-1)
            
            self.visited += [target_node]
            
            next_nodes = target_node.generate_next_moves()
            
            if next_nodes is None:
                self.end_nodes += [target_node]
            
            else:
                self.unvisited += next_nodes
    
            
tree = state_tree(states)

tree.depth_first_search()

print(tree.end_nodes)