算法学习系列（二十）：树与图的DFS与BFS

引言

关于这个树与图考察的还是比较多的，其实就是图，树就是一种特殊的图，树是一种无环无向图，关于图本文主要介绍图的存储方式以及他们的DFS与BFS模板怎么写，并且介绍了相应的例题。

一、图的存储

稠密图用邻接矩阵（n ^ 2 == m），稀疏图用邻接表(n == m)。

1.邻接矩阵

邻接矩阵就是给出一个g[a][b]代表，结点a到结点b存在一条边，权重为g[a][b]，若是无边可用INF代替。一般若是有重边的话，一般取最小的那一条。

2.邻接表

邻接表和哈希算法的拉链法很像，h数组代表每个结点，每个结点自成一个链表的头结点，代表与之相连的边。这里讲的都是有向图，无向图就相当于每条无向边都是两个有向边。

int h[N], e[M], ne[M], w[N], idx;

void add(int a, int b, int c)  //a->b，权重为c
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

二、图的DFS

1.模板

//这里就拿邻接表来举例
const int N = 1e5+10;

int n, m;
int h[N], e[N], w[N], ne[N], idx;
bool st[N];

void dfs(int u)  //代表当前访问的结点的编号
{
    st[u] = true;
    
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];  //j代表连边的编号，i代表的是idx
        if(st[j]) continue;  //访问过了就返回
    }
}

2. 例题：树的重心

给定一颗树，树中包含 n 个结点（编号 1∼n）和 n−1 条无向边。

请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。

重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。

输入格式
第一行包含整数 n，表示树的结点数。
接下来 n−1 行，每行包含两个整数 a 和 b，表示点 a 和点 b 之间存在一条边。

输出格式
输出一个整数 m，表示将重心删除后，剩余各个连通块中点数的最大值。

数据范围
1≤n≤105

输入样例
9
1 2
1 7
1 4
2 8
2 5
4 3
3 9
4 6
输出样例：
4

#include 
#include 
#include 

using namespace std;

const int N = 1e5+10, M = N * 2,INF = 0x3f3f3f3f;

int n, ans = INF;
int h[N], e[M], ne[M], idx;
bool st[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int dfs(int u)
{
    st[u] = true;
    
    int size = 0, sum = 1;  //size代表当前u结点连通块的最大值，sum代表当前结点所连通的结点数和
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if(st[j]) continue;
        
        int s = dfs(j);
        size = max(size, s);
        sum += s;
    }
    
    size = max(size, n - sum);  //因为是dfs遍历的只能找到下面的结点，上面相连的连通块拿总和一减就知道了
    ans = min(ans, size);
    
    return sum;
}

int main()
{
    memset(h, -1, sizeof h);
    
    scanf("%d", &n);
    
    for(int i = 0; i < n - 1; ++i) 
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a,b), add(b,a);  //无向边的处理
    }
    
    dfs(1);
    
    printf("%d\n", ans);
    
    return 0;
}

三、图的BFS

注意：当求最短路问题时，只有当每条边的权重都是一样的那么，才可以用BFS来求最短路问题，否则你第一次到达的路径，不一定是最短的，这时候就得用迪杰斯特拉等最短路算法来求了。

1.模板

//这里就拿邻接表来举例
const int N = 1e5+10, INF = 0x3f3f3f3f;

int start, end;
int h[N], e[N], w[N], ne[N], idx;  //w[i]也是边idx对应的权重
int dist[N], q[N];  //这里的dist[i]的i代表的是idx，也就是边

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

int bfs(int start)  
{
    memset(dist, 0x3f, sizeof dist);
    dist[start] = 0;
    
    int hh = 0, tt = -1;
    q[++tt] = start;
    while(hh <= tt)
    {
        auto t = q[hh++];
        
        if(t == end) return dist[t];
        
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(dist[j] != INF) continue;
            
            dist[j] = dist[t] + w[i];
            q[++tt] = j;
        }
    }
    
    return -1;
}

2.例题：图中点的层次

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环。

所有边的长度都是 1，点的编号为 1∼n。

请你求出 1 号点到 n 号点的最短距离，如果从 1号点无法走到 n 号点，输出 −1。

输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含两个整数 a 和 b，表示存在一条从 a 走到 b 的长度为 1 的边。

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。

数据范围
1≤n,m≤105

输入样例：
4 5
1 2
2 3
3 4
1 3
1 4
输出样例：
1

#include 
#include 
#include 

using namespace std;

const int N = 1e5, M = N * 2;

int n, m;
int h[N], e[M], ne[M], idx;
int dist[M], q[M];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int bfs()
{
    memset(dist, -1, sizeof dist);  //因为权重都为1所以不考虑负边
    dist[1] = 0;
    
    int hh = 0, tt = -1;
    q[++tt] = 1;
    while(hh <= tt)
    {
        auto t = q[hh++];
        
        if(t == n) return dist[t];
        
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(dist[j] != -1) continue;
            
            dist[j] = dist[t] + 1;
            q[++tt] = j;
        }
    }
    
    return -1;
}

int main()
{
    memset(h, -1, sizeof h);
    
    scanf("%d%d", &n, &m);
    
    while(m--)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a,b);  //就算有重边和自环，每条边的权重都为1，所以没影响
    }
    
    printf("%d\n", bfs());
}