Question

我正在从数字的输入文件中实现强连接组件程序。我知道如何执行此操作的算法，但很难在python中实现它。

强连接组分（G） 1.在G上运行DFS以计算完成时间计算G' 3.在G'上运行DFS，但在选择要访问哪个节点时按完成时间减少的顺序（在步骤1中计算） 4.输出深度优先林中每棵树的顶点步骤3作为单独的强连接组件

该文件如下所示：

第一行是否定的。节点和边缘的其余部分是由空格分隔的两个整数u和v，这意味着从节点u到节点v的有向边。输出是强连通分量和这些分量的数量。

DFS(G)
1 for each vertex u in G.V
2     u.color = WHITE
3     u.π = NIL
4 time = 0
5 for each vertex u in G.V
6     if u.color == WHITE
7         DFS-VISIT(G, u)

DFS-VISIT(G, u)
1 time = time + 1 // white vertex u has just been discovered
2 u.d = time
3 u.color = GRAY
4 for each v in G.adj[u]
5     if v.color == WHITE
6         v.π = u
7         DFS-VISIT(G, u)
8 u.color = BLACK // blacken u; it is finished
9 time = time + 1
10 u.f = time

在上面的算法中，我应该如何遍历反向图以找到SCC。

Answer 1

这里，用Python实现。

请注意我构建G和G＆＃39;同时。我的DFS也被修改了。 visited数组存储每个节点所在的组件。此外，DFS接收sequence参数，即测试节点的顺序。在第一个DFS中，我们传递一个xrange（n），但在第二次，我们从第一次执行中传递反转（顺序）。

该程序将输出如下内容：

3
[1, 1, 1, 2, 3]

在该输出中，我们有3个强连接组件，其中3个第一个节点位于单个组件中，其余两个组件各有一个组件。

def DFSvisit(G, v, visited, order, component):
    visited[v] = component
    for w in G[v]:
        if not visited[w]:
            DFSvisit(G, w, visited, order, component)
    order.append(v);

def DFS(G, sequence, visited, order):
    components = 0
    for v in sequence:
        if not visited[v]:
            components += 1
            DFSvisit(G, v, visited, order, components)

n, m = (int(i) for i in raw_input().strip().split())

G = [[] for i in xrange(n)]
Gt = [[] for i in xrange(n)]
for i in xrange(m):
    a, b = (int(i) for i in raw_input().strip().split())
    G[a-1].append(b-1)
    Gt[b-1].append(a-1)

order = []
components = [0]*n

DFS(G, xrange(n), [0]*n, order)
DFS(Gt, reversed(order), components, [])

print max(components)
print components

Answer 2

class graphSCC:
    def __init__(self, graplist):
        self.graphlist = graphlist
        self.visitedNode = {}
        self.SCC_dict = {}      
        self.reversegraph = {}

def reversegraph(self):
    for edge in self.graphlist:
        line = edge.split("\t")
        self.reverseGraph.setdefault(strip("\r"), []).append()
    return self.reverseGraph

def dfs(self):
    SCC_count = 0
    for x in self.reversegraph.keys():
        self.visitednode[x] = 0

    for x in self.reversegraph.keys():
        if self.visitednode[x] == 0:
            count += 1
            self.explore(x, count)

def explore(self, node, count):
    self.visitednode[node] = 1

    for val in self.reversegraph[node]:
        if self.visitednode[val] == 0:
            self.explore(val, count)
    self.SCC_dict.setdefault(count, []).append(node)

length = 0
node = 0
for x in graph.SCC_dict.keys():
    if length < len(graph.SCC_dict[x]):
        length = len(graph.SCC_dict[x])
        node = x

长度是必需的答案

为文件中的整数实现强连接组件

2 个答案: