डोनाल्ड बी जॉनसन एल्गोरिथ्म में स्यूडोकोड को समझना

छद्म कोड अल्गोल, पास्कल या एडीए की याद ताजा करती है।

मतलब यह है कि मैं एक एल्गोरिथ्म है कि एक पाता लागू करना _{कश्मीर} मैट्रिक्स?

एक _{कश्मीर} निर्दिष्ट गुण इनपुट मानों की सरणियों की एक सूची प्रतीत होता है। यह इसी से संबंधित हो सकता निकटता मैट्रिक्स , लेकिन यह मेरे लिए स्पष्ट नहीं है। मैं कुछ इस तरह अनुमान लगा रहा हूँ:

int[][] a = new int[k][n];
int[][] b = new int[k][n];
boolean[] blocked = new boolean[n];
int s;

क्या करता है logical fमतलब है?

यह एक स्थानीय चर एक का प्रतिनिधित्व वाणी trueया falseमूल्य, जावा के लिए इसी तरह की boolean।

logical procedure CIRCUIT (integer value v);

इस नाम के एक Subprogram वाणी CIRCUITएक भी पूर्णांक पैरामीटर होने vकि मूल्य द्वारा पारित कर दिया है। Subprogram एक रिटर्न logicalका परिणाम trueया false, और CIRCUIT := fप्रदान करती है fपरिणाम के रूप में। जावा में,

boolean circuit(int v) {
    boolean f;
    ...
    f = false;
    ...
    return f;
}

कीवर्ड beginऔर end, एक ब्लॉक गुंजाइश है कि नेस्ट किया जा सकता है परिसीमित तो CIRCUITमुख्य ब्लॉक में नीडिंत है और UNBLOCKके अंदर नीडिंत है CIRCUIT। :=काम है, ¬है not; ∈तत्व है; ∅खाली है; ≠है !=; stackऔर unstackसुझाव है pushऔर pop।

यह केवल एक शुरुआत है, लेकिन मुझे आशा है कि यह मदद करता है।

परिशिष्ट: प्रतिबिंब पर, Aऔर Bisomorphic होना चाहिए।

यहाँ एक है बहुत शाब्दिक रूपरेखा। मैं के बारे में पर्याप्त जानकारी नहीं है A, Bऔर Vसरणियों तुलना में एक बेहतर डेटा संरचना चुनने के लिए।

import java.util.Stack;

public final class CircuitFinding {
    static int k, n;
    int[][] a = new int[k][n];
    int[][] b = new int[k][n];
    boolean[] blocked = new boolean[n];
    int[] v = new int[k];
    int s = 1;
    Stack<Integer> stack = new Stack<Integer>();

    private void unblock(int u) {
        blocked[u] = false;
        for (int w : b[u]) {
            //delete w from B(u)
            if (blocked[w]) {
                unblock(w);
            }
        }
    }

    private boolean circuit(int v) {
        boolean f = false;
        stack.push(v);
        blocked[v] = true;
        L1:
        for (int w : a[v]) {
            if (w == s) {
                //output circuit composed of stack followed by s;
                f = true;
            } else if (!blocked[w]) {
                if (circuit(w)) {
                    f = true;
                }
            }
        }
        L2:
        if (f) {
            unblock(v);
        } else {
            for (int w : a[v]) {
                //if (v∉B(w)) put v on B(w);
            }
        }
        v = stack.pop();
        return f;
    }

    public void main() {
        while (s < n) {
            //A:= adjacency structure of strong component K with least
            //vertex in subgraph of G induced by {s, s+ 1, n};
            if (a[k] != null) {
                //s := least vertex in V;
                for (int i : v) {
                    blocked[i] = false;
                    b[i] = null;
                }
                L3:
                circuit(s);
                s++;
            } else {
                s = n;
            }
        }
    }
}