Inzicht in de pseudocode in de Donald B. Johnson's algoritme

De pseudo-code doet denken aan Algol, Pascal en Ada.

Betekent dat ik een algoritme dat de A vindt implementeren _k matrix?

Een _k blijkt een lijst arrays invoerwaarden die het opgegeven eigenschappen zijn. Het kan worden gerelateerd aan de bijbehorende adjacentiematrix , maar het is mij niet duidelijk. Ik gok dat zoiets als dit:

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

Wat betekent logical fdat?

Dit verklaart een lokale variabele die een trueof falsewaarde, vergelijkbaar met Java boolean.

logical procedure CIRCUIT (integer value v);

Dit verklaart een subprogramma met de naam CIRCUITmet een enkele integer parameter vdie wordt doorgegeven door de waarde. Het subprogramma retourneert een logicalresultaat van trueof false, en CIRCUIT := fkent fals resultaat. In Java,

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

De zoekwoorden beginen endbegrenzen een blok ruimte die kan worden genest, dat CIRCUITis genest in het hoofdblok en UNBLOCKgenest binnenin CIRCUIT. :=is opdracht; ¬is not; ∈element is; ∅is leeg; ≠is !=; stacken unstacksuggereren pushen pop.

Het is slechts een begin, maar ik hoop dat het helpt.

Addendum: Bij nader inzien, Aen Bmoet isomorf zijn.

Hier is een zeer letterlijke omtrek. Ik weet niet genoeg over te weten A, Ben Vom een betere datastructuur dan arrays te kiezen.

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;
            }
        }
    }
}