《啊哈算法》第五章 图的遍历

参考：《啊哈算法》

针对前面的广度和深度搜索都是针对图的遍历而言的。但是为什么前面操作的时候并没有提到过图尼。图一般有两种存储方式，一种是邻接矩阵，一种是邻接表。而我们常用邻接矩阵，对图的邻接矩阵遍历大致也是bfs和dfs方法了。

深度优先遍历的主要思想：

首先以一个未被访问过的顶点作为起始顶点，沿当前顶点的边走到未访问过的顶点；当没有未访问过的顶点时，则回到上一个顶点，继续试探访问别的顶点，直到所有的顶点都被访问过。显然，深度优先遍历是沿着图的某一条分支遍历到末端，然后回溯，再沿着另一条进行同样的遍历，直到所有的顶点都被访问为止。（啊哈算法)

图的优先遍历搜索与前面我们的搜索的区别在于存储的时候按照的规则是不同的。

问题

输入无向图的顶点数和边数，再输入边，请输出深度优先遍历的点的顺序

dfs展示

#include <cstdio>
#define N 21
int e[N][N];
int sum=0;
int book[N];//注意这里的book数组是一维的而图的存储是二位的，他们并没有点对点的一一对应，区分开
int a,b;
void dfs(int cur) {//这就比较有意思了，已经晕了在这里
    printf("%d ",cur);
    sum++;
    if(sum==a) {
        return ;
    }
    for(int i=1; i<=a; i++) {
        if(e[cur][i]==1&&book[i]==0) {
            book[i]=1;
            dfs(i);//不回收，因为我们指定了顺序，从1开始
        }
    }
}
int main() {
    scanf("%d%d",&a,&b);
    for(int i=1; i<=a; i++) {//初始化矩阵，一般用0表示自回路，无穷代表没有连接
        for(int j=1; j<=b; j++) {
            if(i==j) {
                e[i][j]=0;
            } else {
                e[i][j]=999999;
            }
        }
    }
    int c,d;
    for(int i=1; i<=b; i++) {//输入边
        scanf("%d%d",&c,&d);
        e[c][d]=1;
        e[d][c]=1;//无向图
    }
    printf("\n");
    book[1]=1;//从1开始，先表明1已经访问过了，若不表明则会重复访问一次1,因此总次数不变的情况下，结果错误
    dfs(1);
    printf("\n");
    return 0;
}

bfs展示：（为什么对bfs这么熟悉，自己写的，但是dfs好像还是不熟练，，。）

#include <cstdio>
#define N 21
int e[N][N];
int book[N];
int que[N];
int main() {
    int a,b;
    scanf("%d%d",&a,&b);
    for(int i=1; i<=a; i++) {
        for(int j=1; j<=a; j++) {
            if(i==j) {
                e[i][j]=0;
            } else {
                e[i][j]=999999;
            }
        }
    }
    int c,d;
    for(int i=1; i<=b; i++) {
        scanf("%d%d",&c,&d);
        e[c][d]=1;
        e[d][c]=1;
    }
    printf("\n");
    int head=1;
    int tail=1;
    que[head]=1;
    book[1]=1;
    tail++;
    while(head<tail) {
        printf("%d ",que[head]);
        for(int i=1; i<=a; i++) {
            if(e[head][i]==1&&book[i]==0) {
                book[i]=1;
                que[tail]=i;
                tail++;
            }
        }
        head++;
    }
    printf("\n");
    return 0;
}

上面两个程序的测试：

5 5
1 2
1 3
1 5
2 4
3 5

图的优先遍历之有权边寻找最短路径

上面讨论的是给出一个无向或有向图，然后给定初始点进行遍历

比如，dfs的例子就是初始点开始到全都遍历结束的遍历路径。

接下来讨论，给定图，并给定边权值，求出到某一位置的最短路径。

问题

输入n,m分别代表图（本题输入为有向图）的顶点数和边，再输入各边的权值，求出初始点到目标的最短路径，这列设定初始点为1，目标为最大点位置

dfs展示：

#include<cstdio>
#define N 21
#define M 99999
int e[N][N];
int min=M;
int book[N];
int a,b;
void dfs(int cur,int dis) {
    if(dis>min) {//这就是为什么要带着路程一起走的原因，可能预判要是dis已经比已知的路程大了也就没有必要再再走下去了
        return ;
    }
    if(cur==5) {
        if(dis<min) {
            min=dis;
        }
        return ;
    }//这两个return都是返回最近一次调用dfs的地方
    for(int i=1; i<=a; i++) {
        if(book[i]==0&&e[cur][i]!=M) {
            book[i]=1;
            dfs(i,dis+e[cur][i]);
            book[i]=0;
        }
    }
}
int main() {
    scanf("%d%d",&a,&b);
    int c,d,va;
    //初始化二维矩阵
    for(int i=1; i<=a; i++) {
        for(int j=1; j<=a; j++) {
            if(i==j) {
                e[i][j]=0;
            } else {
                e[i][j]=M;
            }
        }
    }
    //输入边
    for(int i=0; i<b; i++) {
        scanf("%d%d%d",&c,&d,&va);
        e[c][d]=va;
    }
    book[1]=1;//从1开始，一定要先标记，不要想着dfs里面会标记
    dfs(1,0);//当前所在顶点及已经走过的路程
    printf("%d\n",min);
    return 0;
}

测试：

5 8
1 2 2
1 5 10
2 3 3 
2 5 7
3 1 4
3 4 4 
4 5 5 
5 3 3 

这里就不写bfs了。bfs更适用于所有边的权值相同的情况。同时，处理无向图也是一样的方法

图的优先遍历之bfs找最短路径（边权都相同）

额，前面提到过，bfs第一次到达目的地一定是步数最少的情况，当然是在边权（无向图）都一样的情况下。

问题

第一行输入四个数字，代表图的顶点数，边数，初始位置，目的位置。再输入对应边

bfs展示：

#include <cstdio>
#define M 9999
#define N 21
int e[N][N];
typedef struct Que {//比较路径一般用这样的方式存储
    int x;
    int s;
};
int book[N];
int main() {
    Que que[M];
    int a,b,c,d;
    scanf("%d%d%d%d",&a,&b,&c,&d);
    int n,m,l;
    for(int i=1; i<=a; i++) {
        for(int j=1; j<=a; j++) {
            if(i==j) {
                e[i][j]=0;
            } else {
                e[i][j]=M;
            }
        }
    }
    for(int i=1; i<=b; i++) {
        scanf("%d%d",&n,&m);
        e[n][m]=1;
        e[m][n]=1;
    }
    int head=1;
    int tail=1;
    book[head]=1;
    que[head].x=c;
    que[head].s=0;
    tail++;
    int flag=0;
    while(head<tail) {
        int cur=que[head].x;
        for(int i=1; i<=a; i++) {
            if(book[i]==0&&e[cur][i]!=M) {
                book[i]=1;
                que[tail].x=i;
                if(i==d) {
                    flag=1;
                    break;
                }
                que[tail].s=que[head].s+1;
                tail++;
            }

        }
        if(flag) {
            break;
        }
        head++;
    }
    printf("%d\n",que[tail-1].s);
    return 0;
}

嗯，一般深度优先用于尝试寻找各边权不一样的最短路径，当然bfs也是能够实现的，只是可能比较麻烦，因为每次的总路程不是dfs那样到最后才解决。bfs多用于所有边权值一样的情况。