use dfs to find path in graph finished

Author: Zu3zz

.vscode/settings.json

@@ -2,6 +2,7 @@
   "python.linting.pylintEnabled": true,
   "python.pythonPath": "/Users/3zz/anaconda3/bin/python",
   "files.associations": {
-    "vector": "cpp"
+    "vector": "cpp",
+    "ostream": "cpp"
   }
 }

graph-theory/04-DFS-in-graph/Components

@@ -0,0 +1,62 @@
+#include <iostream>
+#include <cassert>
+
+using namespace std;
+
+// 求无权图的联通分量
+template <typename Graph>
+class Component{
+private:
+  Graph &G;  // 图的引用
+  bool *visited; // 记录dfs的过程中节点是否被访问
+  int ccount; // 记录联通分量的个数
+  int *id; // 每个节点所对应的联通分量值
+  
+  // 图的深度优先遍历
+  void dfs(int v){
+    visited[v] = true;
+    id[v] = ccount;
+    typename Graph::adjIterator adj(G,v);
+    for(int i = adj.begin(); !adj.end();i = adj.next())
+    {
+      if(!visited[i]){
+        dfs(i);
+      }
+    }
+  }
+public:
+  Component(Graph &graph): G(graph){
+    // 初始化数组
+    visited = new bool[G.V()];
+    id = new int[G.V()];
+    ccount = 0;
+    for(int i = 0; i < G.V(); i++)
+    {
+      visited[i] = false;
+      id[i] = -1;
+    }
+    // 求联通分量的个数
+    for(int i = 0; i < G.V(); i++)
+    {
+      if(!visited[i]){
+        dfs(i);
+        ccount++;
+      }
+    }
+  }
+  // 析构函数
+  ~Component(){
+    delete[] visited;
+    delete[] id;
+  }
+  // 返回图的联通分量个数
+  int count(){
+    return ccount;
+  }
+  int isConnected(int v,int w){
+    assert( v >= 0 && v < G.V());
+    assert( w >= 0 && w < G.V());
+    return id[v] == id[w];
+  }
+  
+};

graph-theory/05-path-find/Components.h

@@ -0,0 +1,86 @@
+#include <iostream>
+#include <cassert>
+#include <vector>
+
+using namespace std;
+
+class DenseGraph{
+private:
+  int n, m;               // 节点数和边数
+  bool directed;          // 是否为有向图
+  vector<vector<bool> > g; // 图的具体数据
+
+public:
+  // 构造函数
+  DenseGraph(int n, bool directed){
+    assert(n >= 0);
+    this->n = n;
+    this->m = 0;
+    this->directed = directed;
+    for(int i = 0; i < n; i++)
+    {
+      g.push_back(vector<bool>(n, false));
+    }
+  }
+  ~DenseGraph(){}
+
+  int V(){return n;}
+  int E(){return m;}
+
+  void addEdge(int v, int w){
+    assert(v >= 0 && v < n);
+    assert(w >= 0 && w < n);
+    if(hasEdge(v,w)){
+      return;
+    }
+    g[v][w] = true;
+    if(!directed){
+      g[w][v] = true;
+    }
+    m++;
+  }
+  
+  bool hasEdge(int v, int w){
+    assert(v >= 0 && v <n);
+    assert(w >= 0 && w < n);
+    return g[v][w];
+  }
+  // 打印邻接矩阵
+  void show(){
+    for(int i = 0; i< n;i++){
+      for(int j = 0;j<n;j++){
+        cout<<g[i][j]<<"\t";
+      }
+      cout<<endl;
+    }
+  }
+
+  class adjIterator{
+  private:
+    DenseGraph &G;
+    int v;
+    int index;
+  public:
+    adjIterator(DenseGraph &graph, int v): G(graph){
+      assert( v>=0 && v< G.n);
+      this->v = v;
+      this->index = -1;
+    }
+    ~adjIterator(){}
+    // 返回图G中与顶点v相连接的第一个顶点
+    int begin(){
+      // 索引从-1开始, 因为每次遍历都需要调用一次next()
+      index = -1;
+      return next();
+    }
+    int next(){
+      for(index +=1;index < G.V();index++)
+        if(G.g[v][index])
+          return index;
+        return -1;
+    }
+    bool end(){
+      return index >= G.V();
+    }
+  };
+};

graph-theory/05-path-find/DenseGraph.h

@@ -0,0 +1,109 @@
+//
+// Created by 3zz on 9/22/16.
+//
+
+#ifndef INC_06_FINDING_A_PATH_PATH_H
+#define INC_06_FINDING_A_PATH_PATH_H
+
+#include <vector>
+#include <stack>
+#include <iostream>
+#include <cassert>
+
+using namespace std;
+
+// 路径查询
+template <typename Graph>
+class Path{
+
+private:
+    Graph &G;   // 图的引用
+    int s;      // 起始点
+    bool* visited;  // 记录dfs的过程中节点是否被访问
+    int * from;     // 记录路径, from[i]表示查找的路径上i的上一个节点
+
+    // 图的深度优先遍历
+    void dfs( int v ){
+
+        visited[v] = true;
+
+        typename Graph::adjIterator adj(G, v);
+        for( int i = adj.begin() ; !adj.end() ; i = adj.next() ){
+            if( !visited[i] ){
+                from[i] = v;
+                dfs(i);
+            }
+        }
+    }
+
+public:
+    // 构造函数, 寻路算法, 寻找图graph从s点到其他点的路径
+    Path(Graph &graph, int s):G(graph){
+
+        // 算法初始化
+        assert( s >= 0 && s < G.V() );
+
+        visited = new bool[G.V()];
+        from = new int[G.V()];
+        for( int i = 0 ; i < G.V() ; i ++ ){
+            visited[i] = false;
+            from[i] = -1;
+        }
+        this->s = s;
+
+        // 寻路算法
+        dfs(s);
+    }
+
+    // 析构函数
+    ~Path(){
+
+        delete [] visited;
+        delete [] from;
+    }
+
+    // 查询从s点到w点是否有路径
+    bool hasPath(int w){
+        assert( w >= 0 && w < G.V() );
+        return visited[w];
+    }
+
+    // 查询从s点到w点的路径, 存放在vec中
+    void path(int w, vector<int> &vec){
+
+        assert( hasPath(w) );
+
+        stack<int> s;
+        // 通过from数组逆向查找到从s到w的路径, 存放到栈中
+        int p = w;
+        while( p != -1 ){
+            s.push(p);
+            p = from[p];
+        }
+
+        // 从栈中依次取出元素, 获得顺序的从s到w的路径
+        vec.clear();
+        while( !s.empty() ){
+            vec.push_back( s.top() );
+            s.pop();
+        }
+    }
+
+    // 打印出从s点到w点的路径
+    void showPath(int w){
+
+        assert( hasPath(w) );
+
+        vector<int> vec;
+        path( w , vec );
+        for( int i = 0 ; i < vec.size() ; i ++ ){
+            cout<<vec[i];
+            if( i == vec.size() - 1 )
+                cout<<endl;
+            else
+                cout<<" -> ";
+        }
+    }
+};
+
+#endif //INC_06_FINDING_A_PATH_PATH_H

graph-theory/05-path-find/Path.h

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <cassert>
+#include <sstream>
+
+using namespace std;
+
+template <typename Graph>
+
+class ReadGraph{
+
+public:
+  ReadGraph(Graph &graph, const string &filename){
+    ifstream file(filename);
+    string line;
+    int V,E;
+
+    assert( file.is_open());
+    assert(getline(file, line));
+
+    stringstream ss(line);
+    ss>>V>>E;
+
+    assert(V == graph.V());
+    for(int i = 0; i < E; i++)
+    {
+      assert(getline(file,line));
+      stringstream ss(line);
+
+      int a,b;
+      ss>>a>>b;
+      assert(a >= 0 && a< V);
+      assert(b >= 0 && b < V);
+      graph.addEdge(a,b);
+    }
+  }
+};