Nápověda v Donalds B. Johnson algoritmu, nemohu pochopit pseudo kód (část II)

Jsem Podané s editační žádost kódu @ trashgod pro upevnění výjimku vyvolána v unblock(). V podstatě algoritmus říká, že element w(což není index) má být odstraněn ze seznamu. Výše uvedený kód použit list.remove(w), který zachází wjako index.

My editovat žádost byla zamítnuta! Nejste si jisti, proč, protože jsem otestoval na výše uvedené se svou změnou v síti 20.000 uzlů a 70.000 hrany a to nespadne.

Také jsem upravil Johnsonův algoritmus být více přizpůsobeny neorientovaných grafech. Pokud někdo chce tyto úpravy, prosím, kontaktujte mě.

Níže je můj kód 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 Vaše vzorek výstup obsahuje cyklus, které jsou cyklické permutace. Například 0-1-0 a 1-0-1 jsou stejné skutečnosti výstup by měl obsahuje pouze 5 cyklu tj 0 1 0, 0 2 0 0 1 2 0, 0 2 1 0, 1 2 1,

Johnson papíru vysvětlit, co je to cyklus, je: ‚Dvě základní okruhy jsou odlišné, pokud není cyklická obměna druhého. "Je také možné zjistit wolframové strana: To také výstup 5 cyklus pro stejný vstup.

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

Následující varianta vytváří unikátní cyklů. Na základě tohoto příkladu , to je přizpůsobena z odpovědí poskytnutých @ user1406062 .

Kód:

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

Výstup:

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

Všechny cykly, k odkazu:

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