注意：我们统一用邻接矩阵和邻接表来存储树和图
int h[N], e[N], ne[N], w[N], idx;
int g[N][N];
void add(int a, int b, int c) //a->b 边权为c
{
e[idx] = b;
w[idx] = c
ne[idx] = h[a];
h[a] = idx ++;
}
void add(int a,int b, int c)
{
g[a][b] = c;
}0x21树和图的遍历
树与图的dfs遍历，dfs序，深度和重心
dfs遍历树与图
void dfs(int x)
{
vis[x] = true;
for(int i = h[x]; i != -1 ; i = ne[i])
{
int y = e[i];
if(vis[y]) continue;
dfs(y);
}
}时间复杂度为边数加节点数M+N
时间戳
即每个节点被访问的顺序，我们只需要记录每一个节点被打上“已访问”时的cnt即可代码如下
int cnt[N], t = 1;
void dfs(int x)
{
cnt[x] = t ++;
for(int i = h[x]; i != -1 ; i = ne[i])
{
int y = e[i];
if(cnt[y]) continue;
dfs(y);
}
}树的DFS序
我们在对树进行dfs时，对于每个节点，刚进入递归和即将回溯前记录一次该点的编号，最终得到的长度为2N的节点序列就称为DFS序，记每个节点编号为x在序列中出现的位置分别为L[x]和R[x]那么在[L[x]，R[x]]内就是以x为根的子数的DFS序，后续问题会涉及此技巧，代码如下：
int a[N], k;
void dfs(int x)
{
a[k++] = x; //记录第一次访问x节点
vis[x] = true;
for(int i = h[x]; i != -1 ; i = ne[i])
{
int y = e[i];
if(vis[y]) continue;
dfs(y);
}
a[k++] = x; //记录x节点回溯
}二叉树的先序
二叉树的中序
二叉树的后序
树的深度
树的深度是一种自顶向下的属性，我们可以在遍历的过程中结合递推记录下该属性，代码如下：
int d[N];
void dfs(int x)
{
vis[x] = true;
for(int i = h[x]; i != -1 ; i = ne[i])
{
int y = e[i];
if(vis[y]) continue;
d[y] = d[x] + 1;//y是x的子节点，则深度等于父节点深度+1
dfs(y);
}
}树的重心
在介绍树的重心之前，我们先来介绍一下以每个节点x为根的子树大小size[x]，这是一种自底向上的属性，求得每个节点对应的size代码如下：
int sz[N];
void dfs(int x)
{
vis[x] = true;
sz[x] = 1; //子树x的大小,包含其本身
for(int i = h[x]; i != -1 ; i = ne[i])
{
int y = e[i];
if(vis[y]) continue;
dfs(y);
sz[x] += sz[y];
}
}树的重心是一个节点，对于节点x，把该节点删去后，原来的一颗树会划分成若干子树，记这些子树的最大sz等于max_part(x)，那么重心p就是使得max_part(x)取得最小值的x，通过下面的代码我们可以得出p节点以及max_part(p)：
int sz[N], ans = 0x3f3f3f3f, pos;
void dfs(int x)
{
int max_part = 0;
vis[x] = true;
sz[x] = 1; //子树x的大小,包含其本身
for(int i = h[x]; i != -1 ; i = ne[i])
{
int y = e[i];
if(vis[y]) continue;
dfs(y);
sz[x] += sz[y];
max_part = max(max_part, sz[y]);
}
max_part = max(max_part, n - sz[x]);
if(max_part < ans)
{
pos = x;
ans = max_part;
}
}图的连通块划分
连通块，就是在一个子图中，任意两个点之间都存在一条路径，dfs每从x开始遍历，就会访问x能够到达的所有点与边，因此对N个节点做一次dfs就能划分出一张无向图中的各个连通块，或者是森林中的每课树，代码如下：
int vis[N], cnt;
//cnt记录了连通块的个数，同时也划分了每个点属于哪个连通块，vis[x]标记x属于第几个连通块
void dfs(int x)
{
vis[x] = cnt;
for(int i = h[x]; i != -1 ; i = ne[i])
{
int y = e[i];
if(vis[y]) continue;
dfs(y);
}
}
for(int i = 1 ; i <= n ; i ++)
{
if(vis[i]) continue;
cnt ++;
dfs(i);
}树与图的BFS，拓扑排序
树与图的BFS
我们用一个队列queue来实现，每次从队头取出一个节点x，沿着x节点往后走，把尚未访问过的节点加入队尾，代码如下：
int d[N];//用d[x]来表示节点在树中的深度,或者表示在图中x到起点的最少步数(+1)
void bfs()
{
memset(d, 0, sizeof d);
queue<int> q; q.push(1); d[1] = 1;
while(q.size())
{
int ver = q.front();
q.pop();
for(int i = head[ver], i != -1; i = ne[i])
{
int y = e[i];
if(d[y]) continue;
q.push(y);
d[y] = d[x] + 1;
}
}
}拓扑排序
给定一张有向无环图，存在这样一个由图中所有点构成的序列，对于图中的所有边x->y，x在A中都出现在y之前，则称A是该有向无环图的一个拓扑序列，可以证明有向无环图才至少存在一个拓扑序列，其求解方案如下：
- 预处理出所有点的入度deg[i]，把所有入度为0的点加入队列中
- 取出队头节点x，把x加入拓扑序列seq的末尾
- 遍历x出发的所有边（x，y）， 把deg[y] 减1，若被减为0，则把y入队
- 重复前面的过程，直到队列为空
我们每一次加入入度为0的点，就能保证在这个节点加入之前，没有任何节点有边指向该节点，如此便能保证拓扑序列的要求。
最后按顺序输出seq序列中的数字即可
// seq存储拓扑序列, deg记录每个点的入度
int seq[N], deg[N], cnt;
bool topsort()
{
queue<int> q;
for(int i = 1; i <= n ; i ++)
if(!deg[i]) q.push(i);
while(q.size())
{
int t = q.front();
q.pop();
seq[++cnt] = t;
for(int i = h[t]; i != -1; i = ne[i])
{
int y = e[i];
if(--deg[y] == 0) q.push(y);
}
}
return cnt == n;
}拓扑排序可以用来判断有向图中是否存在环，若seq的序列长度小于图中点的数量，就说明某些节点未被遍历，进而说明图中有环的存在，进一步的解释如下：
先来看一下求拓扑序列的算法， 我们每次--deg[i]实际就是擦除i这个节点的一条边的过程，而对于无环图来说，我们一定能擦除掉任何一个节点的所有入边。（如下图）
这是因为我们是自顶向下的擦除，取的是队列中的节点，并擦除该节点指向的节点的这条边，若存在环的话（如下图）
对于B这个点，入度为2，我们最多只能通过A节点擦除一条A->B的边，使其入度为1，之后就没有途径再使其入度减小，那么节点B就不会加入到队列中，继而就不会加入到拓扑序列中。
