i sözde kod anlayamıyorum, Donalds B. Johnson'un algoritmada yardımcı (BÖLÜM II)

Bir sumbitted vardı düzenleme atılmış istisna düzeltmek için @ trashgod koduna isteği unblock(). Esas olarak, algoritma elemanı belirtir w(ki olmayan bir indeks) listeden kaldırılır etmektir. Kullanılan, yukarıda kod list.remove(w)davranır, wbir indeks olarak.

Benim düzenleme isteği reddedildi! Ben 20,000 düğümler ve 70.000 kenarları bir ağ üzerinde benim modifikasyonu ile yukarıda test edilmiş ve çünkü o çökmez neden emin değilim.

Ayrıca Johnson algoritması daha yönsüz grafiklere uyarlanması değiştirdiniz. Herkes bu değişiklikleri istiyorsa benimle irtibata geçin.

Aşağıda benim kodudur 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, örnek çıkış siklik permütasyon olan döngüsü içerir. Örneğin 0-1-0 ve 1-0-1 Aslında çıkış gereken içeren aynı sadece 5 döngü, yani 0 1 0, 0 2 0, 0 1 2 0, 0 2 1, 0, 1 2 1,

Biri diğerinin döngüsel permütasyon değilse 'İki temel devreler farklıdır: Johnson kağıt bir döngü ne olduğunu açıklar. 'Bir de volfram sayfasına bakabilirsiniz: Bu aynı zamanda çıkış 5 döngüsünü aynı girişi için.

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

Aşağıdaki varyasyon benzersiz döngüleri üretir. Buna göre , örneğin , bir uyarlanmıştır cevap temin @ user1406062 .

Kod:

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

Çıktı:

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

referans için tüm döngüler:

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