基于深度遍历DFS思想实现寻找两点间所有简单路径的寻找

    实现的功能：求两点间的所有简单路径

题目：

    思路：基于深度遍历的思想

    首先是图的ADT的编写，图的ADT中主要包括

    私有成员 numVertex(用于记录节点个数） , numEdge（用于记录边的个数），××Edge(用于创建邻接矩阵，init()函数，用于对图的初始化

    邻接矩阵的说明：邻接矩阵是一个n*n的矩阵，每个矩阵的元素用于记录相对应的节点v (所在的行）和节点w(所在的列）之间边的权值，如果没有边，则将权值设为0

    公有成员构造函数（调用init（）函数，实现图的初始化），析构函数（用于删除图的邻接矩阵，释放空间），

    int n() 函数，用于返回节点数量

    int e() 函数，用于返回边的数量

    int first（int n）函数，用于返回与第n个节点相连的第一个节点

    int next(int n, int w)函数，用于返回与第n个节点相连的节点w的下一个节点

    void setEdge(int v, int w, int wh)函数，用于设置节点v与节点w相连的边的权重为wh

    void deleEdge(int v, int w)函数，顾名思义，就是删除与节点v和节点w相连的边

    bool isEdge(int v, int w)函数，用于返回节点v和w之间是否存在边

    int weight(int v, int w)函数，用于返回节点v和w之间的权重

    M getMark(int v)函数，用于返回标记数组的标记（数据类型为模板的M类型）

    void setMark(int v, M val)函数，用于设置标记数组的第v元素为val

    void print()函数，用于打印邻接矩阵

    整个Graph.h类的源代码如下：

#include <iostream>
using namespace std;
template <typename M>
class Graph {
    private:
        int numVertex,numEdge;
        int **Edge;
        M *mark;
        void Init(int n) {
            Edge= new int*[n];
            for(int i=0; i<n; i++) Edge[i]=new int[n];
            for(int i=0; i<n; i++)
                for(int j=0; j<n; j++)
                    Edge[i][j]=0;
            mark=new M[n];
            numVertex=n;
            numEdge=0;
        }
    public:
        Graph(int n) {
             Init(n);
        }
        ~Graph() {
            delete []mark;
            for(int i=0; i<numVertex; i++) delete []Edge[i];
            delete []Edge;
        }
        int n() { return numVertex; }
        int e() { return numEdge; }
        int first(int n) {
            for(int i=0; i<numVertex; i++)
                if(Edge[n][i]!=0)
                    return i;
            return numVertex ;
        }
        int next(int n, int w) {
            for(int i=w+1; i<numVertex; i++)
                if(Edge[n][i]!=0)
                    return i;
            return numVertex;
        }
        void setEdge(int v, int w, int wh) {
            if(wh<=0){ cout<<"wrong! The edge cannot <=0"<<endl; return; }
            if(Edge[v][w]==0)numEdge++;
            Edge[v][w]=wh;
        }
        void deleEdge(int v, int w) {
            if(Edge[v][w]!=0)numEdge--;
            Edge[v][w]=0;
        }
        bool isEdge(int v, int w) {
            if(Edge[v][w]==0)return false;
            return true;
        }
        int weight(int v, int w) {
            return Edge[v][w];
        }
        M getMark(int v) { if(v>=numVertex )cout<<"越界"<<endl; return mark[v]; }
        void setMark(int v, M val) { mark[v]=val; }
        void print() {
            for(int i=0; i<numVertex; i++) {
                for(int j=0; j<numVertex; j++)
                    cout<<Edge[i][j]<<' ';
                cout<<endl;
            }
        }
}

    好了，接下来进入正题，两点之间所有简单路径的寻找

    首先，定义出一个基于深度搜素算法的函数DFS_all（），此函数为本功能的核心，参数为Graph<int> &G(记得一定要用引用，因为函数里面的Mark值改变了，并且要函数全局有效）, string u（当前节点编号）, string v（终结节点编号）, string *path（路径节点存储数组）, int &d（记录遍历过的节点数量）, map<string,int> &vert, map<int,string> &vert1（这两个映射为将邻接矩阵的节点与节点编号对应）, int &flag(用于记录路径数量，最后返回给函数)；

    关于DFS_all（）函数的：

    首先，找出u,v编号对应的邻接矩阵的节点，以便于接下来的判断，然后设置当前节点为已读，并且将当前节点存入节点路径的数组里面去，节点遍历数++。

    判断当前节点是否与终结节点相等如果相等，则证明存在路径，然后将节点路径打印出来，如果不等，接着遍历与当前节点相连的接着的节点。

    最后是本函数的关键--回溯，如何将访问过的节点变为未访问状态，并且以便于接下来的查找呢？回溯，将当前节点重新标回未访问状态，并且让遍历节点数减一个：d- -。返回路径数flag。

    接下来定义一个find_all函数用于对DFS_all函数参数path数组，遍历节点数d，存在路径数flag，Mark标记数组初始化。

    主函数就不说了.........，自己看代码吧？

#include <iostream>
#include <map>
#include "Graph.h"
using namespace std;
int DFS_all(Graph<int> &G, string u, string v, string *path, int &d, map<string,int> &vert, map<int,string> &vert1, int &flag) {
    int n=vert[u];
    int v1=vert[v];
    G.setMark(n,1);
    path[d]=u;
    d++;
    if(n==v1&&d>=1) {
       flag++;
       cout<<"这两个城市间第"<<flag<<"条简单路径为：";
       for(int i=0; i<d-1; i++)
            cout<<path[i]<<"-->";
            cout<<path[d-1]<<endl;
   }
    else {
        for(int w=G.first(n); w<G.n(); w=G.next(n,w)) {
            if(G.getMark(w)==0)
                DFS_all(G,vert1[w],v,path,d,vert,vert1,flag);
         }
    }
    G.setMark(n,0);  //算法关键，回溯，将访问过状态变为未访问状态
    d--;
    return flag;
}
void find_all(Graph<int> &G, string u, string v, map<string,int> vert, map<int,string> vert1) {
    string path[G.n()+10];
    int d=0;
    int flag=0;
    for(int i=0; i<G.n(); i++)G.setMark(i,0);
    int temp=DFS_all(G,u,v,path,d,vert,vert1,flag);
    if(temp==0)cout<<"这两地之间没有简单路径"<<endl;
}
int main() {
    map<string,int> vert;
    map<int,string> vert1;
    cout<<"输入城市数量：";
    int n;
    cin>>n;
    Graph<int> g(n);
    cout<<"输入城市编号。"<<endl;
    string a,b;
    for(int i=0; i<n; i++) {
        cin>>a;
        vert[a]=i;
        vert1[i]=a;
    }
    cout<<"输入城市间的道路，以‘#’结束。"<<endl;
    while(cin>>a && a!="#") {
        cin>>b;
        g.setEdge(vert[a],vert[b],1);
        g.setEdge(vert[b],vert[a],1);
    }
    cout<<"邻接矩阵表达为"<<endl;
    g.print();
    cout<<"输入要查询的两地代号."<<endl;
    while(cin>>a>>b)
        find_all(g,a,b,vert,vert1);
    return 0;
}

引以为傲的测试结果 ：

   附：此为湖大信科院数据结构第六次实验题目。