(भाग II) Donalds बी जॉनसन एल्गोरिथ्म में मदद, मैं छद्म कोड नहीं समझ सकता

मैं एक sumbitted था संपादित @ trashgod के कोड में अनुरोध अपवाद में फेंक दिया ठीक करने के लिए unblock()। अनिवार्य रूप से, एल्गोरिथ्म कहा गया है कि तत्व w(जो नहीं एक सूचकांक) सूची से हटा दिया है। इसके बाद के संस्करण कोड का इस्तेमाल किया list.remove(w)है, जो व्यवहार करता है wएक सूचकांक के रूप में।

मेरे संपादित अनुरोध को अस्वीकार कर दिया गया था! सुनिश्चित नहीं हैं कि क्यों, क्योंकि मैं 20,000 नोड्स और 70,000 किनारों का एक नेटवर्क पर अपने संशोधन के साथ ऊपर का परीक्षण किया और है यह दुर्घटना नहीं करता है।

मैं भी अधिक अनिर्दिष्ट रेखांकन करने के लिए अनुकूलित किया जाना जॉनसन एल्गोरिथ्म संशोधित किया है। किसी को भी इन संशोधनों चाहता है मुझसे संपर्क करें।

नीचे के लिए अपने कोड है 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, अपने नमूना उत्पादन चक्र है जो चक्रीय परिवर्तन होते हैं। उदाहरण के लिए 0-1-0 और 1-0-1 ही कर रहे हैं वास्तव में उत्पादन करना चाहिए होता है केवल 5 चक्र यानी 0 1 0, 0 2 0, 0 1 2 0, 0 2 1 0, 1 2 1,

जॉनसन कागज की व्याख्या क्या एक चक्र है: अगर एक दूसरे के एक चक्रीय परिवर्तन नहीं है 'दो प्राथमिक सर्किट अलग हैं। एक ही इनपुट के लिए यह भी उत्पादन 5 चक्र: 'एक भी Wolfram पेज देख सकते हैं।

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

निम्नलिखित भिन्नता अद्वितीय चक्र पैदा करता है। इसके आधार पर उदाहरण , यह एक से अनुकूलित है इस सवाल का जवाब द्वारा आपूर्ति @ user1406062 ।

कोड:

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

आउटपुट:

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

सभी चक्र, संदर्भ के लिए:

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