Question

我必须在给定的图表中找到长度为3的所有周期。我已经使用BFS实现了它，但到目前为止它仅适用于相对较小的输入。它仍适用于较大的并给出正确答案，但找到答案所需的时间非常长。有没有办法改进以下代码，使其更有效？

num_res = 0
adj_list = []
cycles_list = []


def bfs_cycles(start):
    queue = [(start, [start])]
    depth = 0
    while queue and depth <= 3:
        (vertex, path) = queue.pop(0)
        current_set = set(adj_list[vertex]) - set(path)
        if start in set(adj_list[vertex]):
            current_set = current_set.union([start])
        depth = len(path)
        for node in current_set:
            if node == start:
                if depth == 3 and sorted(path) not in cycles_list:
                    cycles_list.append(sorted(path))
                    yield path + [node]
            else:
                queue.append((node, path + [node]))


if __name__ == "__main__":
    num_towns, num_pairs = [int(x) for x in input().split()]
    adj_list = [[] for x in range(num_towns)]
    adj_matrix = [[0 for x in range(num_towns)] for x in range(num_towns)]

    # EDGE LIST TO ADJACENCY LIST
    for i in range(num_pairs):
        cur_start, cur_end = [int(x) for x in input().split()]
        adj_list[cur_start].append(cur_end)
        adj_list[cur_end].append(cur_start)

    num_cycles = 0

    for i in range(num_towns):
        my_list = list(bfs_cycles(i))
        num_cycles += len(my_list)

    print(num_cycles)

输入示例：

（输出：20;工作正常）

（输出：11061;大约需要10秒）

Answer 1

代码中的一些问题：

操作sorted(path) not in cycles_list具有O(n)复杂度，其中n的大小为cycles_list
queue.pop(0)具有O(n)复杂度，其中n是queue的大小。您应该使用collections.deque structure，而不是此处的列表。

作为一般说明，除非你真的需要使用专门的BFS解决问题（例如因为有些人要求你使用这种方法），所以循环的简单组合可以更好地完成工作。伪代码：

 num_loops = 0
 for a in nodes:
   for b in neighbors(a)
     if b > a:
       for c in neighbors(b):
         if c > b and a in neighbors(c):
           num_loops += 1

添加b > a和c > b检查只计算每个循环一次。

Answer 2

对于像3这样的少数步骤，如果您可以在3个步骤内离开并返回节点，则可以检查每个节点。

这种方法运行得相当快：

import fileinput

graph = {}

# Recursive function to find a goal in a number of steps
def count_unique_walks(start, goal, length, visited=[]):
    if length == 0:
        # Out of steps
        return 1 if start == goal else 0
    if start in visited:
        # Already been here
        return 0
    result = 0
    for neighbor in graph[start]:
        if neighbor < start and neighbor != goal:
            # Count only unique cycles
            continue
        result += count_unique_walks(neighbor, goal, length-1, visited+[start])
    return result

# Read input
for line in fileinput.input():
    a, b = map(int, line.split())
    if a not in graph:
        graph[a] = set()
    graph[a].add(b)
    if b not in graph:
        graph[b] = set()
    graph[b].add(a)

# Sum up the cycles of each node
result = 0
for node in graph:
    result += count_unique_walks(node, node, 3)
print result

BFS查找所有固定长度的周期

2 个答案: