Java 理解Donald B.Johnson'；s算法

有人知道吗，它列举了有向图中的所有基本回路（循环）

我有他1975年发表的论文，但我不能理解伪代码

我的目标是用Java实现这个算法

我有一些问题，例如，它所指的矩阵Ak是什么。在伪代码中，它提到

Ak:=adjacency structure of strong component K with least 
    vertex in subgraph of G induced by {s,s+1,....n};

这是否意味着我必须实现另一个算法来找到Ak矩阵

另一个问题是下面的意思是什么

begin logical f; 

行

“逻辑过程电路（整数值v）；”

是否也表示电路过程返回逻辑变量？伪代码中还有一行“

电路：=f；

”。这是什么意思

如果有人能把这个1970年代的伪代码翻译成一种更现代的伪代码，这样我就能理解它，那就太好了

---

如果您有兴趣提供帮助，但找不到论文，请发电子邮件至pitelk@hotmail.com我会把论文发给你。

伪代码让人想起Algol、Pascal或Ada

这是否意味着我必须实现另一个算法来找到Ak矩阵

Ak似乎是具有指定属性的输入值数组的列表。它可能与相应的事件有关，但我不清楚。我猜是这样的：

int[][] a = new int[k][n];
int[][] b = new int[k][n];
boolean[] blocked = new boolean[n];
int s;

逻辑f

是什么意思

这声明了一个表示

true

或

false

值的局部变量，类似于Java的

boolean

逻辑程序电路（整数值v）

这声明了一个名为
CIRCUIT
的子程序，它有一个通过值传递的整数参数
v
。子程序返回
真
或
假
的
逻辑
结果，并且
电路：=f
分配
f
作为结果。在爪哇

boolean circuit(int v) {
    boolean f;
    ...
    f = false;
    ...
    return f;
}

关键字
开始
和
结束
限定了一个可以嵌套的块范围，因此
电路
嵌套在主块中，
取消阻塞
嵌套在
电路
中<代码>：=

是分配<代码>是

不是
<代码>∈is元素<代码>∅为空<代码>≠是
=<代码>堆栈
和
取消堆栈
建议
推送
和
弹出

这只是一个开始，但我希望能有所帮助

附录：经过反思，
A
和
B
必须同构

这里有一个非常字面的大纲。我对
A
、
B
和
V
了解不够，无法选择比数组更好的数据结构

import java.util.Stack;

public final class CircuitFinding {
    static int k, n;
    int[][] a = new int[k][n];
    int[][] b = new int[k][n];
    boolean[] blocked = new boolean[n];
    int[] v = new int[k];
    int s = 1;
    Stack<Integer> stack = new Stack<Integer>();

    private void unblock(int u) {
        blocked[u] = false;
        for (int w : b[u]) {
            //delete w from B(u)
            if (blocked[w]) {
                unblock(w);
            }
        }
    }

    private boolean circuit(int v) {
        boolean f = false;
        stack.push(v);
        blocked[v] = true;
        L1:
        for (int w : a[v]) {
            if (w == s) {
                //output circuit composed of stack followed by s;
                f = true;
            } else if (!blocked[w]) {
                if (circuit(w)) {
                    f = true;
                }
            }
        }
        L2:
        if (f) {
            unblock(v);
        } else {
            for (int w : a[v]) {
                //if (v∉B(w)) put v on B(w);
            }
        }
        v = stack.pop();
        return f;
    }

    public void main() {
        while (s < n) {
            //A:= adjacency structure of strong component K with least
            //vertex in subgraph of G induced by {s, s+ 1, n};
            if (a[k] != null) {
                //s := least vertex in V;
                for (int i : v) {
                    blocked[i] = false;
                    b[i] = null;
                }
                L3:
                circuit(s);
                s++;
            } else {
                s = n;
            }
        }
    }
}

import java.util.Stack；
公共最终类查找{
静态int k，n；
int[]a=新的int[k][n]；
int[]b=新的int[k][n]；
布尔[]阻塞=新布尔[n]；
int[]v=新的int[k]；
int s=1；
堆栈=新堆栈（）；
专用无效解除阻止（int u）{
阻塞的[u]=假；
对于（整数w:b[u]）{
//从B（u）中删除w
如果（阻止[w]）{
解锁（w）；
}
}
}
专用布尔电路（int v）{
布尔f=假；
栈推（v）；
阻塞[v]=真；
L1:
for（int w:a[v]）{
如果（w==s）{
//输出电路由堆栈和s组成；
f=真；
}否则，如果（！阻塞[w]）{
中频（电路（w））{
f=真；
}
}
}
L2：
如果（f）{
解锁（v）；
}否则{
for（int w:a[v]）{
//如果（v）∉B（w））将v置于B（w）上；
}
}
v=stack.pop（）；
返回f；
}
公共图书馆{
而（s
您可以在github上找到此算法的Java实现：。它使用了Jung2 java图形库。
您是否尝试阅读链接到的论文？它似乎有一个附带的解释和证明。是的，我有，但它仍然没有解释代码本身，只是一般的想法。我不能理解的是伪代码。此外，我还找到了该论文的另一个链接，以防第一个链接不起作用。多亏了你们，你们已经注意到了我问题的外观（使它看起来更好；纠正拼写错误并将我写的代码更改为论文的原始代码-出于某种奇怪的原因，我无法复制-粘贴代码，因此我从头开始键入。）
AK
指的是顶点的诱导子图的边列表
VK
。Mathematica演示（和源代码）是可用的。非常感谢您提供的信息。但我仍然无法取得任何重大进展。我将尝试找出ada或algol语法。在此之前，您能否向我澄清一些事情？电路：=f以immiadetly方式返回值，或者只是指定稍后返回的值？换句话说，它类似于f=false或like return（f=假）感谢语句
CIRCUIT:=f
指定局部变量
f
的当前值，作为子程序在以下语句之后正常退出时的结果。赋值不会导致返回；它只是在返回之前。使用标识符
CIRCUIT
并不意味着递归，而
取消阻塞
似乎是递归调用的