搜索与图论——树与图的遍历：拓扑排序

1.树与图的存储
树是一种特殊的图，与图的存储方式相同。
对于无向图中的边ab，存储两条有向边a->b, b->a。
因此我们可以只考虑有向图的存储。

(1) 邻接矩阵：g[a][b] 存储边a->b

邻接矩阵的缺点：浪费空间

(2) 邻接表：

其中使用数组模拟领接表时，h[]的下标为节点的编号，h[]中的值是指向其子节点的”指针“，e[]的下标相当于地址，本身并没有意义，e[]中的值是子节点的编号，ne[]的下标与对应的e[]下标相同，与e[]构成一个节点，其下标也相当于地址，本身无意义。ne[]中的值是指向其兄弟节点的”指针“。

// 对于每个点k，开一个单链表，存储k所有可以走到的点。h[k]存储这个单链表的头结点
int h[N], e[N], ne[N], idx;

// 添加一条边a->b
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

// 初始化
idx = 0;
memset(h, -1, sizeof h);

2. 树与图的遍历
（1）深度优先遍历——模板题：树的重心
给定一颗树，树中包含n个结点（编号1~n）和n-1条无向边。

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

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

输入格式
第一行包含整数n，表示树的结点数。

接下来n-1行，每行包含两个整数a和b，表示点a和点b之间存在一条边。

输出格式
输出一个整数m，表示重心的所有的子树中最大的子树的结点数目。

数据范围
1≤n≤10⁵
输入样例
9
1 2
1 7
1 4
2 8
2 5
4 3
3 9
4 6

输出样例
4

解题思路：
这道题的题意其实就是在所有节点中找到某个节点，使以该节点为根的最大子树的节点数最小
所以我们只需要在遍历某个节点时记录该节点的最大子树，在所有子树都遍历完后，跟新答案就可以了

#include<isotream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 100010, M = N * 2;

int n;
int h[N], e[M], ne[M], idx; // h[N]邻接表头，e[M]数据域，ne[M]指针域，idx当前位置
bool st[N]; // 某个点是否被查找过

int ans = N;

// 插入一条边
void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

// 返回以u为根的树中点的数量
int dfs(int u)
{
	st[u] = true; // 标记一下， 已经被搜过了
	
	int sum = 1, res = 0;  // sum表示该点以及他所有子树的节点数目，res记录最大值
	for(int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];
		if(!st[j])
		{
			int s = dfs(j);		//s存储节点u其中一个子树的节点数
			res = max(res, s);	//不断跟新最大子树的节点数目
			sum += s;			
		}
	}
	res = max(res, n - sum); 

	ans = min(ans, res);
	return sum;
}

int main()
{
	cin >> n;
	memset(h, -1, sizeof(h));

	for(int i = 0; i < n - 1; i++)
	{
		int a, b;
		cin >> a >> b;
		add(a, b), add(b, a);
	}

	dfs(1);

	cout << ans << endl;

	return 0;
}						

(2) 宽度优先遍历——模板题：图中点的层次
给定一个n个点m条边的有向图，图中可能存在重边和自环。

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

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

输入格式
第一行包含两个整数n和m。

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

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

数据范围
1≤n,m≤10⁵
输入样例
4 5
1 2
2 3
3 4
1 3
1 4

输出样例
1

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], idx;
int d[N], q[N]; // d[N]储存到起点的距离，q[N]存储队列

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

int bfs()
{
	int hh = 0, tt = 0;
	q[0] = 1; // 搜索起点

	memset(d, -1, sizeof(d));
	
	d[1] = 0;

	// 从队头开始宽度搜索
	while(hh <= tt)
	{
		int t = q[hh++];

		for(int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			if(d[j] == -1)
			{
				d[j] = d[t] + 1;
				q[++tt] = j;
			}
		}
	}
	return d[n];
}

int main()
{
	cin >> n >> m;

	memset(h, -1, sizeof(h));

	for(int i = 0; i < m; i++)
	{
		int a, b;
		cin >> a >> b;
		add(a, b);
	}

	cout << bfs() << endl;
	
	return 0;
}							

3. 树与图遍历的应用——拓扑排序
模板题：有向图的拓扑序列
给定一个n个点m条边的有向图，点的编号是1到n，图中可能存在重边和自环。

请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出-1。

若一个由图中所有点构成的序列A满足：对于图中的每条边(x, y)，x在A中都出现在y之前，则称A是该图的一个拓扑序列。

输入格式
第一行包含两个整数n和m

接下来m行，每行包含两个整数x和y，表示存在一条从点x到点y的有向边(x, y)。

输出格式
共一行，如果存在拓扑序列，则输出拓扑序列。
否则输出-1。

数据范围
1≤n,m≤10⁵
输入样例
3 3
1 2
2 3
1 3
输出样例
1 2 3

解题思路：
记录每个点的入度数量，然后从入度为0的节点开始宽度优先搜索这个图，在搜索的过程中逐步减去相邻节点的入度，当节点入度为0时就加入队列中，如果最终队列的长度不为n，即可能出现自环某点永远进不了队列，可能图中所在环即那个环中的节点无法进入队列，不存在拓扑序列。

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 100010;

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

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

bool topsort()
{
	int hh = 0, tt = -1;

	for(int i = 1; i <= n; i++)
		if(!d[i])
			q[++tt] = i;
	
	while(hh <= tt)
	{
		int t = q[hh++];
		for(int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			d[j] --;
			if(d[j] == 0) q[++tt] = j;
		}
	}
	
	return tt == n - 1;
}

int main()
{	
	cin >> n >> m;

	memset(h, -1, sizeof(h));

	for(int i = 0; i < m; i++)
	{
		int a, b;
		cin >> a >> b;
		add(a, b);
		d[b]++;
	}
	
	if(topsort())
	{
		for(int i = 0; i < n; i++) printf("%d ", q[i]);
		puts("");
	}
	else puts("-1");
	
	return 0;
}