《算法笔记》学习日记——10.1 图的定义和相关术语&10.2 图的存储&10.3 图的遍历

10.1 图的定义和相关术语

Codeup Contest ID:100000618
PS：这一节没有相关练习。

10.2 图的存储

Codeup Contest ID:100000619
PS：这一节没有相关练习。

10.3 图的遍历

Codeup Contest ID:100000620

问题 A: 第一题

题目描述
该题的目的是要你统计图的连通分支数。
输入
每个输入文件包含若干行，每行两个整数i,j，表示节点i和j之间存在一条边。
输出
输出每个图的联通分支数。
样例输入

1 4
4 3
5 5

样例输出

2

思路
这题需要读懂题目的意思哈，连通分支数应该指给出的图里有几个连通块的意思（突然发现这么想的话好像能用并查集来做？），我一开始理解成了图里有几条路径-_-||。不过这里我还是用了图的DFS搜索来做的，因为不一定是一张连通图，所以需要dfstrave()这个函数来寻找所有的连通块，然后每找到一个连通块，记录数量cnt++。

这里需要注意的是，应该再开一个数组记录输入的编号，否则默认的vis[maxn]数组都是false，遍历图的时候从0~maxi的每个点都会加上去，但事实上，并不是0~maxi的点都存在于这张图内（比如样例给的，只有1、3、4、5这四个点，并没有0、2，这是我们需要剔除的）。
代码

#include<cstdio>
#include<string>
#include<algorithm>
#include<vector>
#include<iostream>
using namespace std;
const int maxn = 1000010;
vector<int> G[maxn];
bool vis[maxn] = {false};
bool hashtable[maxn] = {false};
void dfs(int u){
    vis[u] = true;
    for(int i=0;i<G[u].size();i++){
        int v = G[u][i];
        if(vis[v]==false){
            dfs(v);
        }
    }
}
void dfstrave(int maxi, int &cnt){
    for(int i=0;i<=maxi;i++){
        if(vis[i]==false&&hashtable[i]==true){//如果图中存在这个点,且未被访问过
            cnt++;
            dfs(i);
        }
    }
}
int main(){
    int i, j;
    int cnt = 0;
    int maxi = 0;
    while(scanf("%d%d", &i, &j) != EOF){
        G[i].push_back(j);
        G[j].push_back(i);
        hashtable[i] = true;//记录图中存在的点
        hashtable[j] = true;
        if(i>maxi) maxi = i;
        if(j>maxi) maxi = j;
    }
    dfstrave(maxi, cnt);
    printf("%d\n", cnt);
    return 0;
}

问题 B: 连通图

题目描述
给定一个无向图和其中的所有边，判断这个图是否所有顶点都是连通的。
输入
每组数据的第一行是两个整数 n 和 m（0<=n<=1000）。n 表示图的顶点数目，m 表示图中边的数目。如果 n 为 0 表示输入结束。随后有 m 行数据，每行有两个值 x 和 y（0<x, y <=n），表示顶点 x 和 y 相连，顶点的编号从 1 开始计算。输入不保证这些边是否重复。
输出
对于每组输入数据，如果所有顶点都是连通的，输出"YES"，否则输出"NO"。
样例输入

4 3
4 3
1 2
1 3
5 7
3 5
2 3
1 3
3 2
2 5
3 4
4 1
7 3
6 2
3 1
5 6
0 0

样例输出

YES
YES
NO

思路
这题跟上一题很像，也是数一个图中的连通块的数目，如果连通块的数目为1，那么这张图肯定是一个连通图，也就是说所有顶点之间都是连通的，输出“YES”，如果不是1，说明肯定存在相互之间不连通的点，输出“NO”。
代码

#include<cstdio>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<iostream>
using namespace std;
const int maxn = 1010;
vector<int> G[maxn];
bool vis[maxn] = {false};
void dfs(int u){
    vis[u] = true;
    for(int i=0;i<G[u].size();i++){
        int v = G[u][i];
        if(vis[v]==false){
            dfs(v);
        }
    }
}
void dfstrave(int n, int &cnt){
    for(int i=1;i<=n;i++){
        if(vis[i]==false){
            cnt++;
            dfs(i);
        }
    }
}
int main(){
    int n, m;
    while(scanf("%d%d", &n, &m) != EOF){
        if(n==0&&m==0) break;
        int cnt = 0;
        for(int i=0;i<m;i++){
            int a, b;
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        dfstrave(n, cnt);
        if(cnt==1) printf("YES\n");//如果只有一个连通块,说明图中所有顶点都是连通的
        else printf("NO\n");
        for(int i=0;i<maxn;i++) G[i].clear();
        memset(vis, 0, sizeof(vis));
    }
    return 0;
}

小结

总的来说，图的遍历和树的遍历很像，不过细心观察的话可以发现，图的DFS函数是没有写递归边界的（树的话就是搜索到叶子结点就return，迷宫类问题同理，到死胡同就return），仔细思考了一下应该是因为我们是通过vis[maxn]这个数组来控制是否已访问的结点，如果结点都已经访问，那么DFS自然也不会执行更深层次的递归，也就会回退出来了。

在这里提醒一下自己：如果遇到求层次类的题目（比如书上的那道PAT甲级微博题），还是用BFS更方便，因为BFS本就是按层次的顺序来走的。