搜索与图论---树与图的遍历

树与图的深度优先遍历

DFS遍历方式

每个节点只遍历一次，开一个标记数组——bool state[N];

例题1：数的重心 AW846

1. 递归过程为

int dfs(int u)
{
	state[u]=true;
	
	int sum=1,res=0;   
	for(int i=h[u];i!=-1;i=ne[i])   //一直走到链表底，符合DFS
	{
		int j=e[i];
		if(!state[j]) 
		{
			int s=dfs(j);
			res=max(res,s);
			sum+=s;   //sum每次初始化的时候值为1，也就是每次递归过程从底部开始会向上记录其父节点子树节点的个数
		}
	}       
	res=max(res,n-sum);//某结点上面连通块的点数值为：n - (当前点的子树的点数)
	ans=min(ans,res);   //找最小值进行输出
	
	return sum;  //返回值的意义是传sum值到下一层，因为下一层的局部变量res值为0
}

2. 枚举每个点被去掉之后剩余连通块点的个数，再算最大值

如下图所示，结点4上面连通块的点数值为：n - (4子树的点数)

#include<iostream>
#include<stdio.h>
#include<cstring> 
#include<cmath>
#include<algorithm>
using namespace std; 
const int N=100003,M=N*2; //边的数量最多能达到两倍

int n;
int h[N],e[M],ne[M],idx;   //h存n个链表的链表头
//之后三个是链表基本结构：节点上的值,存储下一个节点，当前处理到了哪
bool state[N];		//每个节点只遍历一次，开一个标记数组
int ans=N;  //存放答案，要存全局变量

void add(int a,int b)  //单链表基本操作
{
	e[idx]=b;
	ne[idx]=h[a];    //h数组相当于一个特殊的ne数组
	h[a]=idx++;
}


int dfs(int u)
{
	state[u]=true;
	
	int sum=1,res=0;   
	for(int i=h[u];i!=-1;i=ne[i])   //一直走到链表底，符合DFS
	{
		int j=e[i];
		if(!state[j]) 
		{
			int s=dfs(j);
			res=max(res,s);
			sum+=s;   //sum每次初始化的时候值为1，也就是每次递归过程从底部开始会向上记录其父节点子树节点的个数
		}
	}       
	res=max(res,n-sum);//某结点上面连通块的点数值为：n - (当前点的子树的点数)
	ans=min(ans,res);   //找最小值进行输出
	
	return sum;  //返回值的意义是传sum值到下一层，因为下一层的局部变量res值为0
}
//依次枚举：删掉每一个点之后剩余各个连通块中点数(点的个数)的最大值
int main()
{
	cin>>n;
	memset(h,-1,sizeof(h));
	for(int i=1;i<=n-1;i++)   //n个结点的树中只包含n-1条边
	{
		int a,b;
		cin>>a>>b;
		add(a,b);
		add(b,a);   //无向图，双向建立边
	}
	dfs(1);
	cout<<ans<<endl;
	return 0;
}

树与图的广度优先遍历

BFS遍历方式

例题1：图中点的层次 AW847

按照BFS的套路，这题的解题思路如下

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], idx;  //链表所需数组
int d[N];    //d存放的是离起点的距离

void add(int a, int b)		//数组模拟链表基本操作
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

int bfs()
{
    memset(d, -1, sizeof d);

    queue<int> q;
    d[1] = 0;     //以1为起点
    q.push(1);

    while (q.size())  //队列不空
    {
        int t = q.front();   //队尾出队
        q.pop();

        for (int i = h[t]; i != -1; i = ne[i])    //扩展每个点的邻边
        {
            int j = e[i];
            if (d[j] == -1)			// 没有被访问过
            {
                d[j] = d[t] + 1;		//层数(距离)加一
                q.push(j);       //j没有被访问过，j入队等待后面的循环进行操作
            }
        }
    }

    return d[n];
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);

    for (int i = 0; i < m; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);
    }

    cout << bfs() << endl;

    return 0;
}

图的宽搜最经典的应用：拓扑序列

拓扑序列是针对有向无环图来说的，有向无环图才会有拓扑序列

拓扑序列的含义：
若一个由图中所有点构成的序列A满足：对于图中的每条边(x, y)，x在A中都出现在y之前，则称A是该图的一个拓扑序列。（即起点在终点的前面、即把他看成一个容器，当没有边指向它的时候就可以 ）

例题：有向图的拓扑序列AW848

思路如下：

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

using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], idx;		//为链表所开的变量
int d[N];		//存储每个点的入度
int q[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;			//遍历，如果发现有入度为0的点则输出

    while (hh <= tt)
    {
        int t = q[hh ++ ];			//队头t

        for (int i = h[t]; i != -1; i = ne[i])	//枚举t的所有出边	
        {
            int j = e[i];
            if (-- d[j] == 0)		//可以拆分成  先删掉那条边 然后判断入度是不是0
                q[ ++ tt] = j;		//加入拓扑序列
        }
    }

    return tt == n - 1;
}

int main()
{
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);

    for (int i = 0; i < m; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);    //存储这条输入的边
        d[b] ++ ;     //b的入度加一（当点的入度为0时被输出）
    }

    if (!topsort()) puts("-1");		//tt != n - 1
    else							//tt == n - 1
    {
        for (int i = 0; i < n; i ++ ) printf("%d ", q[i]);   //输出拓扑序列   
        puts("");
    }

    return 0;
}