关于图中两个顶点间的路径问题

---

用DFS算法求顶点u到v的一条简单路径

题目描述：
设图G是一个连通图，设计一个算法，利用DFS搜索算法，求图中从顶点u到顶点v的一条简单路径，并输出该路径。

算法思想：
从顶点u开始进行深度优先搜索，如果能够搜索到顶点v，即可求得从顶点u到顶点v的一条简单路径，路径上的每个顶点只访问一次。
为了输出这条路径，可设置一个辅助数组Path[]，记录从u到v的路径。

实现代码：

void DFS_path(MGraph &G, int u, int v, int visited[], int Path[], int &k, int &flag){
    //k记录路径上的顶点个数，flag是查找是否成功标志
    if(flag == 1)return;
    visited[u] = 1;
    for(int w=FirstNeighbor(G, u); w!=-1; w=NextNeighbor(G, u, w)){
        if(w == v){
            Path[k++] = v;
            flag = 1;
        }else if(!visited[w]){
            Path[k++] = w;
            DFS_path(G, w, v, visited, Path, k, flag);
        }
    }
}
void PrintPath(MGraph &G, int u, int v){
    int visited[G.vexnum], Path[G.vexnum];
    int k=0, flag=0;
    for(int i=0; i<G.vexnum; i++){
        visited[i] = 0;
    }
    Path[k++] = u;
    DFS_path(G, u, v, visited, Path, k, flag);
    cout<<"路径：";
    for(int i=0; i<k-1; i++){
        cout<<Path[i]<<" ";
    }
    cout<<endl;
    cout<<"顶点数："<<k-1;
}

用BFS算法求顶点u到v的一条简单路径

问题描述：
设图G是一个连通图，设计一个算法，利用BFS搜索算法，求图中从顶点u到顶点v的一条简单路径，并输出该路径。

算法思想：
在搜索过程中，设立一个辅助数组pre[n]，当从某个顶点i找到其邻接顶点j进行访问时，将pre[j]置为i。最后，当退出搜索后，根据pre[n]数组输出这条从u到v的路径。

实现代码：

void BFS_Path(MGraph G, int u, int v){
    if(u==-1 || v==-1)return;
    int k=0; //k为路径上的顶点个数
    int visited[G.vexnum], pre[G.vexnum];
    for(int i=0; i<G.vexnum; i++) 
        visited[i] = 0; //初始化标记数组
    pre[k++] = u;
    visited[u] = 1;
    queue<int> vex;
    vex.push(u); //u进队
    while(!vex.empty()){
        int j = vex.front(); //队首元素
        vex.pop();
        for(int w=FirstNeighbor(G,j); w!=-1; w=NextNeighbor(G, j, w)){
            if(!visited[w]){
                pre[k++] = w;
                visited[w] = 1;
                vex.push(w);
            }
        }
    }
    for(int i=0; i<k; i++)
        cout<<pre[i]<<" ";
}

求图中顶点u到顶点v的所有简单路径

问题描述：
设图G是一个连通图，设计一个算法，求图G中从顶点u到顶点v的所有简单路径。

算法思想：
用深度优先搜索来求解。在遍历过程中把访问顶点存放在数组Path中。每当从顶点u出发，通过深度优先遍历到顶点v时，在Path中就可以得到一条从u到v的简单路径。
与普通深度优先搜索算法不同的是，每当从顶点u退出递归回溯时，把visited[u]置为0，下次可通过顶点u找到其他可能到达v的路径。

实现代码：

void DFS_All(MGraph G, int u, int v, int visited[], int Path[], int &k){
    visited[u] = 1;
    Path[k++] = u;
    if(u == v){
        for(int i=0; i<k; i++)
            cout<<Path[i];
        cout<<endl;
    }
    for(int w=FirstNeighbor(G,u); w!=-1; w=NextNeighbor(G, u, w)){
        if(!visited[w])
            DFS_All(G, w, v, visited, Path, k);
    }
    visited[u] = 0; //一条简单路径处理完，退回一个顶点继续遍历
    k--;
}
void PrintAll(MGraph G, int u, int v){
    if(u==-1 || v==-1)return;
    int k=0;
    int visited[G.vexnum], Path[G.vexnum];
    for(int i=0; i<G.vexnum; i++)
        visited[i] = 0;
    DFS_All(G, u, v, visited, Path, k);
}

求图中顶点u到顶点v的长度为len的所有简单路径

问题描述：
设图G是一个连通图，设计一个算法，求图G中从顶点u到顶点v的长度为len的所有简单路径。

算法思想：
用深度优先搜索来求解。在遍历过程中把访问顶点存放在数组Path中。每当从顶点u出发，通过深度优先遍历到顶点v时，在Path中就可以得到一条从u到v的简单路径，同时需要用k进行计数，用以检查是否路径长度等于len。
与普通深度优先搜索算法不同的是，每当从顶点u退出递归回溯时，把visited[u]置为0，下次可通过顶点u找到其他可能到达v的路径。

实现代码：

void DFS_All_len(MGraph G, int u, int v, int len, int visited[], int Path[], int &k){
    visited[u] = 1;
    Path[k++] = u;
    if(u==v && k==len){
        for(int i=0; i<k; i++)
            cout<<Path[i];
        cout<<endl;
    }
    for(int w=FirstNeighbor(G,u); w!=-1; w=NextNeighbor(G, u, w)){
        if(!visited[w])
            DFS_All_len(G, w, v, len, visited, Path, k);
    }
    visited[u] = 0; //一条简单路径处理完，退回一个顶点继续遍历
    k--;
}
void PrintAllLen(MGraph G, int u, int v, int len){
    if(u==-1 || v==-1)return;
    int k=0;
    int visited[G.vexnum], Path[G.vexnum];
    for(int i=0; i<G.vexnum; i++)
        visited[i] = 0;
    DFS_All_len(G, u, v, len, visited, Path, k);
}

公共代码部分（邻接矩阵存储建图等基本代码）

#include<bits/stdc++.h>
using namespace std;

#define maxvertexnum 30
typedef struct{
    int Vertex[maxvertexnum]; //顶点表
    int Edge[maxvertexnum][maxvertexnum]; //边表
    int vexnum, edgenum; //顶点数、边数
}MGraph;

//建立无向图
void CreateMGraph(MGraph &G, int v[], int n, int edge[][2], int e){
    G.vexnum = n;
    G.edgenum = e;
    //初始化
    for(int i=0; i<G.vexnum; i++){
        G.Vertex[i] = v[i];
        for(int j=0; j<G.vexnum; j++){
            G.Edge[i][j] = 0;
        }
    }
    for(int i=0; i<G.edgenum; i++){
        int j = edge[i][0];
        int k = edge[i][1];
        G.Edge[j][k] = 1;
        G.Edge[k][j] = 1;
    }
}

树的遍历中用到的函数：

//顶点v的第一个邻接点
int FirstNeighbor(MGraph G, int v){
    if(v!=-1){
        for(int i=0; i<G.vexnum; i++){
            if(G.Edge[v][i] > 0){
                return i;
            }
        }
    }
    return -1;
}
//顶点v的邻接点w的下一个邻接点
int NextNeighbor(MGraph G, int v, int w){
    if(v!=-1 && w!=-1){
        for(int i=w+1; i<G.vexnum; i++){
            if(G.Edge[v][i] > 0){
                return i;
            }
        }
    }
    return -1;
}

主函数：

int main(){
    int n,e;
    cin>>n>>e;
    int v[n], edge[e][2];
    for(int i=0; i<n; i++){
        cin>>v[i];
    }
    for(int i=0; i<n; i++){
        cin>>edge[i][0]>>edge[i][1];
    }
    MGraph G;
    CreateMGraph(G, v, n, edge, e);
    //调用语句，例如PrintAllLen(G, 1, 3, 4);
    return 0;
}