Question

Johnson's paper开始在有向图中描述不同的基本电路（简单周期）：

如果没有顶点，则电路是基本的，但第一个和最后一个出现两次。如果一个不是另一个的循环置换，则两个基本电路是不同的。 G
中有c个不同的基本电路

我试图拼凑出一些模糊地类似于伪代码的东西，有点像networkx和Java implementation那样严重作弊。我显然没有得到明显的基本电路。

这是我的代码。它使用goraph library，但除了获得强连接组件之外，它并没有真正做太多。

package main

import (
    "fmt"
    "github.com/gyuho/goraph/algorithm/scc/tarjan"
    "github.com/gyuho/goraph/graph/gs"
)

func main() {

    gr := gs.NewGraph()

    a := gr.CreateAndAddToGraph("A")
    b := gr.CreateAndAddToGraph("B")
    c := gr.CreateAndAddToGraph("C")
    d := gr.CreateAndAddToGraph("D")
    e := gr.CreateAndAddToGraph("E")
    f := gr.CreateAndAddToGraph("F")

    gr.Connect(a, b, 1)
    gr.Connect(b, c, 1)
    gr.Connect(c, a, 1)

    gr.Connect(d, e, 1)
    gr.Connect(e, f, 1)
    gr.Connect(f, d, 1)

    sccs := tarjan.SCC(gr) // returns [][]string
    for _, scc := range sccs {
        if len(scc) < 3 {
            continue
        }
        for _, v := range scc {
            n := node(v)
            circuit(n, n, gr)
        }
    }
    fmt.Println(result)
}

type node string

var blocked = make(map[node]bool)
var B = make(map[node][]node)
var path []node
var result [][]node

func circuit(thisNode node, startNode node, g *gs.Graph) bool {
    closed := false
    path = append(path, thisNode)
    blocked[thisNode] = true

    adj := g.FindVertexByID(string(thisNode)).GetOutVertices().GetElements()
    for _, next := range adj {
        nextNode := node(next.(*gs.Vertex).ID)

        if nextNode == startNode {
            cycle := []node{}
            cycle = append(cycle, path...)
            cycle = append(cycle, startNode)
            result = append(result, cycle)
            closed = true
        } else if !blocked[nextNode] {
            if circuit(nextNode, startNode, g) {
                closed = true
            }
        }
    }

    if closed {
        unblock(thisNode)
    } else {
        adj = g.FindVertexByID(string(thisNode)).GetOutVertices().GetElements()
        for _, next := range adj {
            nextNode := node(next.(*gs.Vertex).ID)
            inB := false
            for _, v := range B[nextNode] {
                if v == thisNode {
                    inB = true
                }
            }
            if !inB {
                B[nextNode] = append(B[nextNode], thisNode)
            }
        }
    }
    path = path[:len(path)-1]
    return closed
}

func unblock(thisNode node) {
    stack := []node{thisNode}
    for len(stack) > 0 {
        n := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        if blocked[n] {
            blocked[n] = false
            stack = append(stack, B[n]...)
            B[n] = []node{}
        }
    }
}

这是输出：

[[C A B C] [B C A B] [A B C A] [F D E F] [E F D E] [D E F D]]

图论是一个充满魔力的幽灵般的黑暗森林，所以我不确定我错过了什么。我误读了这篇论文吗？是否暗示冗余排列应该以其他方式过滤掉？我搞砸了代码吗？

Answer 1

过滤掉了冗余排列，因为每个返回排列的起始节点总是小于所有剩余元素（在某种排序下）。

我怀疑问题在于缺少这些步骤的实现：

AK：=具有最小顶点的强分量K的邻接结构由{s，s + 1，n}引起的G子图;

和

s：= V中的最小顶点;

这些步骤应该确保每个排列的开始总是小于排列的其余部分，但我看不到代码来实现它，而是你似乎遍历强连接组件中的每个节点。

D. B. Johnson＆＃34;基本电路＆＃34;算法产生明显的结果？

1 个答案: