算法竞赛——树和图的存储与遍历

一、树与图的存储方式

树(无环连通图)、图的存储:

​ 有向图:a ---> b

​ 无向图:a ---> b,b ---> a

无向图可以看作是特殊的有向图!

1.邻接矩阵

稠密图一般使用邻接矩阵存储,空间复杂度达到(n * n)

存储方式:

g[b][b]存储a ---> b的信息,如果有权值cg[b][b] = c;如果没有权值则为bool,表示是否连通

注:邻接矩阵不能存储重边,一般只保留一条最短的:如朴素dijkstra算法和prim算法)

2.邻接表

邻接表适用于存储稀疏图,是一种最常用的图存储方式:对于每一个节点,开一个单链表(类似拉链法)存储该节点可以访问到的点,存储次序无关紧要。

image

插入边:

image

初始化链表:

 memset(h, -1, sizeof h);

插入操作:

不带权值:

//邻接表
int h[N], e[M], ne[M], idx;// M = 2 * N

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

带权值:

int h[N], w[N], e[N], ne[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 ++;
}

二、树与图的遍历方式

1.深度优先遍历

(1)图的深度优先遍历框架模板:

//u为节点编号
void dfs(int u){

    st[u]=true; // 标记一下,记录为已经被搜索过了
    // 遍历u的邻接点
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];//拿到出边的对应的节点编号
        if(!st[j])//如果未被访问过,继续深搜
        {
            dfs(j);
        }
    }
}

(2)例题:树的重心

image

【参考代码】

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

using namespace std;

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

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

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

//返回以u为根节点的子树中节点的个数,包括u节点
int dfs(int u)
{
    st[u] = true;// 标记一下,已经搜索过
    
    //size是表示将u点去除后,剩下的子树中数量的最大值;
    //sum表示以u为根的子树的点的多少,初值为1,因为已经有了u这个点
    int size = 0, sum = 1;
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];//拿到出边的对应的节点编号
        if(!st[j])
        {
            int s = dfs(j); // 当前子树的大小(//s是以j为根节点的子树中点的数量)
            size = max(size, s);// 取子树种节点数较大者
            sum += s;
        }
    }
    //n-sum表示的是减掉u为根的子树,整个树剩下的点的数量
    size = max(size, 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;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);//无向图
    }
    //从第一个节点开始搜索
    dfs(1);
    printf("%d\n", ans);
    
    return 0;
}

2.广度优先遍历

图宽搜的框架和前面BFS的框架基本一模一样,只是将图的结构扩展到宽搜框架里。前面的BFS是根据具体题目来扩展点,的话采用邻接表存储图,从1号节点编号开始,扩展的是每一个点的临边

(1)图的广度优先遍历框架模板:

1. queue <---- 1号点

2. while(队列不为空)
 { 	
    
	t <---队头
	弹出队头

   	扩展队头元素(扩展t的所有邻接点j)
   	{
        获取邻接点(编号)j
   		if(j未遍历,符合条件)// 第一次遍历才是最短路径
   		{
   			queue  <----- j入队// (邻接节点)
   			更新距离 //d[x] = d[t]++
   		 }
   	}

}

3. 最后队为空,结束

(2)例题:图中点的层次

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

所有边的长度都是 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 <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 1e5 + 10;

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

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

int bfs()
{
    
    //初始化距离,且起用于判断是否访问过
    memset(d, -1, sizeof d);
    
    //1.一号节点(编号)入队,设置距离
    queue<int>q;
    q.push(1);
    d[1] = 0;
    
    //2.队列不为空
    while(q.size())
    {
        //2.1拿到队头节点,队头出队
        auto t = q.front();
        q.pop();
        //2.2扩展队头元素(t的所有邻接节点)
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];//得到邻接节点j
            if(d[j] == -1)//如果j节点没有被访问过
            {
                q.push(j);//入队
                d[j] = d[t] + 1;//更新距离
            }
        }
    }
    
    //3.返回结果
    return d[n];
}

int main()
{
    cin >> n >> m;
    //初始化链表
    memset(h, -1, sizeof h);
    
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
    }
    
    cout << bfs();
    
    return 0;
}

(3)图广搜的应用——拓扑排序

基本介绍

拓扑序列:在一个有向图无环中,对所有的节点进行排序,要求没有一个节点指向它前面的节点。即,所有的边从前指向后!

注:无向图没有拓扑序列

入度:一个点有多少条进来(指向自己)的边

出度:一个点有多少条出去(指向其它点)的边

重要结论性质:一个有向无环图至少存在一个入度为0的节点!

求解步骤:

(1)先统计好图中所有点的入度情况

(2)找到图中入度为0的节点,将它删去,由它发射出来的所有边也要删掉,即它指向的邻接节点度数-1

(3)将删去节点后剩下的图,继续按(2)的规则继续删节点。

按照节点被删除的顺序,依次把这些被删除的节点记录要一个序列里边,当图中所有节点被删除后,那么这个序列就是一个拓扑序列了!

image

注:当同时出现两个或以上入度为0的节点时,拓扑序列结果不唯一!

image

基本BFS框架:

bool topsort()
{
	1. queue <---- 所有度为0的点

	2. while queue不为空
	{
		t <---- 队头
		弹出队头
			
		枚举t所有的出边 t ---> j
		{
			删掉出边 t ---> j: d[j] --;// 入度-1
			
			if(d[j] == 0)// 当节点j入度为0时,入队 
			queue <---- j
		}
	}
    
    如果有n - 1个节点入队的话,说明是拓扑序列返回true,否则不是返回false
}

例题:

给定一个 n 个点 m 条边的有向图,点的编号是 1 到 n,图中可能存在重边和自环。

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

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

输入格式

第一行包含两个整数 n 和 m。

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

输出格式

共一行,如果存在拓扑序列,则输出任意一个合法的拓扑序列即可。

否则输出 −1。

数据范围

1≤n,m≤105

输入样例:

3 3
1 2
2 3
1 3

输出样例:

1 2 3

【参考代码】

数组模拟队列:

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

using namespace std;

const int N = 1e5 + 10;

int h[N], e[N], ne[N], idx;
int d[N];//统计节点入度情况
int q[N];//队列
int n, m;

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

bool topsort()
{

    int hh = 0, tt = -1;
    
    //1.
    for (int i = 1; i <= n; i ++ )// 将所有入度为0的点入队
    if(d[i] == 0)
    q[++ tt] = i;
    
    //2.
    while(hh <= tt)
    {
        int t = q[hh ++];// 获取队头元素的同时,也就弹出了队头元素!
        //删掉t的所有出边
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            d[j] --;
            if(d[j] == 0)
            q[++ tt] = j;//当节点j入度为0时,入队
        }
    }
    
    return tt==n-1;
    //表示如果n个点都入队了话,那么该图为拓扑图,返回true,否则返回false
  
}


int main()
{
    
    cin >> n >> m;
    memset(h, -1, sizeof h);
    
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
        d[b] ++;//因为是a指向b,所以b点的入度要加1
    }
    if(topsort())
    {
        for (int i = 0; i < n; i ++ )
        cout << q[i] << " ";
        //经上方循环可以发现队列中的点的次序就是拓扑序列
        //注:拓扑序列的答案并不唯一
        puts("");
    }
    else
    puts("-1");
    
    return 0;
}

STL:queue,开一个top[N]数组来记录拓扑序列!

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


using namespace std;

const int N = 1e5 + 10;

int h[N], e[N], ne[N], idx;
int d[N];//统计节点入度情况
int top[N];//记录拓扑序列
int n, m, cnt;

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

bool topsort()
{

    queue<int>q;
    
    for (int i = 1; i <= n; i ++ )// 将所有入度为0的点入队
    if(d[i] == 0)
    q.push(i);
    
    //2.
    while(q.size())
    {
        int t = q.front();
        top[cnt ++] = t;//加入到 拓扑序列中
        q.pop();
        
        //删掉t的所有出边
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            d[j] --;
            if(d[j] == 0)
            q.push(j);//当节点j入度为0时,入队
        }
    }
    
    return cnt == n;
    //表示如果n个点都入队了话,那么该图为拓扑图,返回true,否则返回false
  
}


int main()
{
    
    cin >> n >> m;
    memset(h, -1, sizeof h);
    
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
        d[b] ++;//因为是a指向b,所以b点的入度要加1
    }
    if(topsort())
    {
        for (int i = 0; i < n; i ++ )
        cout << top[i] << " ";
        //经上方循环可以发现队列中的点的次序就是拓扑序列
        //注:拓扑序列的答案并不唯一
        puts("");
    }
    else
    puts("-1");
    
    return 0;
}

三、总结

在理解思路的基础上,学习总结代码!

学习内容源自:

acwing算法基础课

注:如果文章有任何错误或不足,请各位大佬尽情指出,评论留言留下您宝贵的建议!如果这篇文章对你有些许帮助,希望可爱亲切的您点个赞推荐一手,非常感谢啦

posted @ 2022-01-07 10:42  时间最考验人  阅读(404)  评论(1编辑  收藏  举报