Hilfe bei der Algorithmus Donalds B. Johnson, ich nicht dem Pseudo-Code verstehen kann (Teil II)

Ich hatte eine sumbitted bearbeiten Anfrage @ trashgod der Code die Ausnahme geworfen zu beheben in unblock(). Im Wesentlichen stellt der Algorithmus, der das Element w(das ist nicht ein Index) aus der Liste entfernt werden soll. Der obige Code verwendet list.remove(w), der behandelt wals Index.

Mein bearbeiten Antrag wurde abgelehnt! Nicht sicher , warum, weil ich das oben mit meiner Modifikation in einem Netzwerk von 20.000 Knoten und 70.000 Kanten getestet habe und es nicht abstürzt.

Ich habe auch auf ungerichtete Graphen angepasst Johnsons Algorithmus werden mehr geändert. Wenn jemand diese Änderungen will kontaktieren Sie mich.

Unten ist mein Code für unblock().

private void unblock(int u) {
    blocked[u] = false;
    List<Integer> list = b.get(u);
    int w;
    for (int iw=0; iw < list.size(); iw++) {
        w = Integer.valueOf(list.get(iw));
        //delete w from B(u);
        list.remove(iw);
        if (blocked[w]) {
            unblock(w);
        }
    }
}

@trashgod, Ihre Beispielausgabe enthält Zyklus die zyklische Vertauschung sind. Zum Beispiel 0-1-0 und 1-0-1 gleiche sind eigentlich sollte die Ausgabe enthält nur 5 Zyklus dh 0 1 0, 0 2, 0, 0 1 2 0 0 2 1 0, 1 2 1,

Johnson Papier erklären, was ein Zyklus ist: ‚Zwei Elementarschaltungen sind verschieden, wenn man nicht eine zyklische Permutation des anderen ist. "Man kann auch Wolfram- Seite überprüfen: Diese auch Ausgang 5-Zyklus für den gleichen Eingang.

http://demonstrations.wolfram.com/EnumeratingCyclesOfADirectedGraph/

Die folgende Variante produziert einzigartige Zyklen. Basierend auf diesem Beispiel wird von einer angepassten Antwort geliefert von @ user1406062 .

Code:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;

/**
 * @see https://en.wikipedia.org/wiki/Johnson%27s_algorithm
 * @see https://stackoverflow.com/questions/2908575
 * @see https://stackoverflow.com/questions/2939877
 * @see http://en.wikipedia.org/wiki/Adjacency_matrix
 * @see http://en.wikipedia.org/wiki/Adjacency_list
 */
public final class CircuitFinding {

    final Stack<Integer> stack = new Stack<Integer>();
    final Map<Integer, List<Integer>> a;
    final List<List<Integer>> b;
    final boolean[] blocked;
    final int n;
    Integer s;

    public static void main(String[] args) {
        List<List<Integer>> a = new ArrayList<List<Integer>>();
        a.add(new ArrayList<Integer>(Arrays.asList(1, 2)));
        a.add(new ArrayList<Integer>(Arrays.asList(0, 2)));
        a.add(new ArrayList<Integer>(Arrays.asList(0, 1)));
        CircuitFinding cf = new CircuitFinding(a);
        cf.find();
    }

    /**
     * @param a adjacency structure of strong component K with least vertex in
     * subgraph of G induced by {s, s + 1, n};
     */
    public CircuitFinding(List<List<Integer>> A) {
        this.a = new HashMap<Integer, List<Integer>>(A.size());
        for (int i = 0; i < A.size(); i++) {
            this.a.put(i, new ArrayList<Integer>());
            for (int j : A.get(i)) {
                this.a.get(i).add(j);
            }
        }
        n = a.size();
        blocked = new boolean[n];
        b = new ArrayList<List<Integer>>();
        for (int i = 0; i < n; i++) {
            b.add(new ArrayList<Integer>());
        }
    }

    private void unblock(int u) {
        blocked[u] = false;
        List<Integer> list = b.get(u);
        for (int w : list) {
            //delete w from B(u);
            list.remove(Integer.valueOf(w));
            if (blocked[w]) {
                unblock(w);
            }
        }
    }

    private boolean circuit(int v) {
        boolean f = false;
        stack.push(v);
        blocked[v] = true;
        L1:
        for (int w : a.get(v)) {
            if (w == s) {
                //output circuit composed of stack followed by s;
                for (int i : stack) {
                    System.out.print(i + " ");
                }
                System.out.println(s);
                f = true;
            } else if (!blocked[w]) {
                if (circuit(w)) {
                    f = true;
                }
            }
        }
        L2:
        if (f) {
            unblock(v);
        } else {
            for (int w : a.get(v)) {
                //if (v∉B(w)) put v on B(w);
                if (!b.get(w).contains(v)) {
                    b.get(w).add(v);
                }
            }
        }
        v = stack.pop();
        return f;
    }

    public void find() {
        s = 0;
        while (s < n) {
            if (!a.isEmpty()) {
                //s := least vertex in V;
                L3:
                for (int i : a.keySet()) {
                    b.get(i).clear();
                    blocked[i] = false;
                }
                circuit(s);
                a.remove(s);
                for (Integer j : a.keySet()) {
                    if (a.get(j).contains(s)) {
                        a.get(j).remove(s);
                    }
                }
                s++;
            } else {
                s = n;
            }
        }
    }
}

Ausgabe:

0 1 0
0 1 2 0
0 2 0
0 2 1 0
1 2 1

Alle Zyklen, als Referenz:

0 1 0
0 1 2 0
0 2 0
0 2 1 0
1 0 1
1 0 2 1
1 2 0 1
1 2 1
2 0 1 2
2 0 2
2 1 0 2
2 1 2