helpen bij het Donalds B. Johnson's algoritme, ik kan de pseudo-code niet begrijpen (deel II)

Ik had een sumbitted bewerking verzoek om de code @ trashgod om de uitzondering gegooid in te lossen unblock(). In wezen, het algoritme dat het element w(dat niet een index) is uit de lijst verwijderd. De code gebruikt list.remove(w), die behandeld wals index.

Mijn bewerken verzoek werd afgewezen! Ik weet niet zeker waarom, omdat ik het bovenstaande met mijn modificatie op een netwerk van 20.000 nodes en 70.000 randen hebben getest en is het niet crashen.

Ik heb ook gemodificeerde Johnson's algoritme meer worden aangepast aan de ongerichte grafieken. Als iemand wil dat deze wijzigingen kunt u contact met mij op.

Hieronder is mijn code voor 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, je steekproef uitvoer bevat cyclus welke cyclische permutatie zijn. Bijvoorbeeld 0-1-0 en 1-0-1 zijn gelijk feite de productie moet bevat 5 cyclus dwz 0 1 0 0 2 0 0 1 2 0 0 2 1 0 1 2 1,

Johnson papier uit te leggen wat een cyclus is: 'Two elementaire circuits zijn te onderscheiden als men niet een cyclische permutatie van de ander. 'Men kan ook controleren wolfram pagina Ook dit uitgang 5 cyclus voor dezelfde ingang.

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

De volgende variatie produceert unieke cycli. Op basis van dit voorbeeld wordt omgebouwd antwoord op geleverde @ 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;
            }
        }
    }
}

Output:

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

Alle cycli, ter referentie:

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