dfs 1

Author: iScript

.idea/vcs.xml

@@ -1,10 +1,7 @@
-7 9
+7 6
 0 1
-0 3
-1 2
-1 6
+0 2
+1 3
+1 4
 2 3
-2 5
-3 4
-4 5
-5 6
+2 6

.idea/workspace.xml

@@ -0,0 +1,84 @@
+import java.util.ArrayList;
+
+// Connected Component 联通分量
+public class CC {
+    private Graph G;
+    private int[] visited;
+    private int cccount;
+
+    public CC(Graph G){
+        this.G = G;
+        visited = new int[G.V()];
+        for(int i=0;i<visited.length;i++) visited[i] = -1;
+
+        // 多包一层for，防止有多个联通分量
+        for(int v = 0 ;v<G.V();v++){
+            if(visited[v] == -1 ){
+                dfs(v,cccount);
+                cccount++;
+            }
+
+        }
+    }
+
+    // 深度优先遍历
+    private void dfs(int v,int ccid){
+        visited[v] = ccid;
+        // 遍历相邻节点
+        for(int w : G.adj(v)){
+            if(visited[w] == -1 )
+                dfs(w,ccid);
+        }
+    }
+
+    // 返回几个联通分量
+    public int count(){
+        for(int e : visited){
+            System.out.print(e + " ");
+        }
+        System.out.println();
+        return cccount;
+    }
+
+    // 2个顶点是否相连
+    public boolean isConnected(int v,int w){
+        G.validateVertex(v);
+        G.validateVertex(w);
+        return visited[v] == visited[w];
+    }
+
+    // 返回联通分量数组
+    public ArrayList<Integer>[] components(){
+        ArrayList<Integer>[]  res = new ArrayList[cccount];
+        for(int i=0;i<cccount;i++){
+            res[i] = new ArrayList<>();
+        }
+
+        // 遍历每一个顶点
+        for(int v=0;v<G.V();v++){
+            // 放到各自的联通分量
+            res[visited[v]].add(v);
+        }
+
+        return res;
+    }
+
+
+    public static void main(String[] args){
+
+        Graph g = new Graph("g.txt");
+        CC cc = new CC(g);
+//        System.out.println(cc.count());
+//        System.out.println(cc.isConnected(0,5));
+
+        ArrayList<Integer>[] comp = cc.components();
+        for(int ccid=0;ccid<comp.length;ccid++){
+            System.out.print(ccid + " : ");
+            for(int w:comp[ccid]){
+                System.out.print(w + " ");
+            }
+            System.out.println();
+        }
+
+    }
+}

g.txt

@@ -44,7 +44,7 @@ public Graph(String filename) {
     }
 
 
-    private void validateVertex(int v){
+    public void validateVertex(int v){
         if(v < 0 || v >= V)
             throw new IllegalArgumentException("vertex " + v + "is invalid");
     }

out/production/Graph/CC.class

@@ -0,0 +1,49 @@
+import java.util.ArrayList;
+
+public class GraphDFS {
+
+    private Graph G;
+    private boolean[] visited;
+    private ArrayList<Integer> pre = new ArrayList<>(); //先序遍历结果
+    private ArrayList<Integer> post = new ArrayList<>();//后序遍历结果
+
+    public GraphDFS(Graph G){
+        this.G = G;
+        visited = new boolean[G.V()];
+
+        // 多包一层for，防止有多个联通分量
+        for(int v = 0 ;v<G.V();v++){
+            if(!visited[v])
+                dfs(v);
+        }
+    }
+
+    // 深度优先遍历
+    private void dfs(int v){
+        visited[v] = true;
+        pre.add(v);
+
+        // 遍历相邻节点
+        for(int w : G.adj(v)){
+            if(!visited[w])
+                dfs(w);
+        }
+        post.add(v);
+    }
+
+    public Iterable<Integer> pre(){
+        return pre;
+    }
+
+    public Iterable<Integer> post(){
+        return post;
+    }
+
+    public static void main(String[] args){
+
+        Graph g = new Graph("g.txt");
+        GraphDFS graphDFS = new GraphDFS(g);
+        System.out.println(graphDFS.pre());
+        System.out.println(graphDFS.post());
+    }
+}

out/production/Graph/Graph.class

@@ -0,0 +1,66 @@
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+
+// 单源路径
+public class SingleSourcePath {
+    private Graph G;
+    private int s;
+    private boolean[] visited;
+    private int[] pre;
+
+
+    public SingleSourcePath(Graph G , int s){
+        G.validateVertex(s);
+        this.G = G;
+        this.s = s; // 原点
+        visited = new boolean[G.V()];
+        pre = new int[G.V()];
+
+        for(int i=0;i<pre.length;i++)
+            pre[i] = -1;
+
+        dfs(s,s);
+
+    }
+
+    // 深度优先遍历
+    private void dfs(int v,int parent){
+        visited[v] = true;
+        pre[v] = parent;
+        // 遍历相邻节点
+        for(int w : G.adj(v)){
+            if(!visited[w])
+                dfs(w,v);
+        }
+    }
+
+    // 从源到目标是否可以连接
+    public boolean isConnectedTo(int t){
+        G.validateVertex(t);
+        return visited[t];
+    }
+
+    // 从源到目标的路径
+    public Iterable<Integer> path(int t){
+        ArrayList<Integer> res = new ArrayList<>();
+        if(!isConnectedTo(t)) return res;
+
+        int cur = t;
+        while(cur != s){
+            res.add(cur);
+            cur = pre[cur]; // 上一个节点
+        }
+        res.add(s);
+        Collections.reverse(res);   // 反
+        return res;
+    }
+
+
+    public static void main(String[] args){
+
+        Graph g = new Graph("g.txt");
+        SingleSourcePath singleSourcePath = new SingleSourcePath(g,0);
+        System.out.println(singleSourcePath.path(6));
+    }
+}