关于这个树与图考察的还是比较多的，其实就是图，树就是一种特殊的图，树是一种无环无向图，关于图本文主要介绍图的存储方式以及他们的DFS与BFS模板怎么写，并且介绍了相应的例题。
稠密图用邻接矩阵（n ^ 2 == m），稀疏图用邻接表(n == m)。
邻接矩阵就是给出一个g[a][b]代表，结点a到结点b存在一条边，权重为g[a][b]，若是无边可用INF代替。一般若是有重边的话，一般取最小的那一条。
邻接表和哈希算法的拉链法很像，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++;
}
//这里就拿邻接表来举例
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; //访问过了就返回
}
}
给定一颗树，树中包含 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 <cstdio>
#include <cstring>
#include <iostream>
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来求最短路问题，否则你第一次到达的路径，不一定是最短的，这时候就得用迪杰斯特拉等最短路算法来求了。
//这里就拿邻接表来举例
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;
}
给定一个 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 <cstdio>
#include <cstring>
#include <iostream>
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());
}