Acwing 第三章模板及详解(搜索与图论)

一、DFS与BFS

二、树与图的遍历:拓扑排序

三、最短路

四、最小生成树

五、二分图:染色法、匈牙利算法
 

一、DFS与BFS


概述
DFS:深度优先搜索(Depth-First-Search)

BFS:宽度优先搜索(Breadth-First-Search)

DFS和BFS的对比

DFS使用栈(stack)来实现,BFS使用队列(queue)来实现

DFS所需要的空间是树的高度h,而BFS需要的空间是2h (DFS的空间复杂度较低)

DFS不具有最短路的特性,BFS具有最短路的特性

通常来说,求“最短”的操作,都可以用BFS来做,而其他一些奇怪的操作,或者对空间复杂度要求比较高,则用DFS来做

DFS
DFS中的2个重要概念:

回溯:回溯的时候,一定要记得恢复现场
剪枝:提前判断某个分支一定不合法,直接剪掉该分支

#include
using namespace std;
const int N = 10;

int n;
int path[N];//记录所有的搜索路径
bool st[N];//记录这些点有没有被用过,1表示是,0表示否

void dfs(int u) // 第u层
{
    if(u == n)//从0开始作为第一层,当搜索完最后一层,就输出这条路径并结束递归
    {
        for(int i=0;i>n;
    dfs(0);
    return 0;
}


(1) 深度优先遍历 

int dfs(int u)
{
    st[u] = true; // st[u] 表示点u已经被遍历过

    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j]) dfs(j);
    }
}


(2) 宽度优先遍历

queue q;
st[1] = true; // 表示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 (!st[j])
        {
            st[j] = true; // 表示点j已经被遍历过
            q.push(j);
        }
    }
}


二、树与图的遍历:拓扑排序
首先,树是一种特殊的图(无环连通图)。所以,这里只说图的存储即可。

首先,图分为2种,有向图和无向图。

有向图中2个点之间的边是有方向的,比如a -> b,则只能从a点走到b点,无法从b点走到a点。

无向图中2个点之间的边是没有方向的,比如a - b,则可以从a走到b,也可以从b走到a。

通常,我们可以将无向图看成有向图。比如上面,对a到b之间的边,我们可以建立两条边,分别是a到b的,和b到a的。

所以,我们只需要考虑,有向图如何存储,即可。通常有2种存储方式

邻接矩阵

用一个二维数组来存,比如g[a,b]存储的就是a到b的边。邻接矩阵无法存储重复边,比如a到b之间有2条边,则存不了。(用的较少,因为这种方式比较浪费空间,对于有n个点的图,需要n2的空间,这种存储方式适合存储稠密图)

邻接表

使用单链表来存。对于有n个点的图,我们开n个单链表,每个节点一个单链表。单链表上存的是该节点的邻接点(用的较多)

树和图遍历有2种方式,深度优先遍历和宽度优先遍历。

我们只需要考虑有向图的遍历即可。

树与图的深度优先遍历
由于遍历时,每个点最多只会被遍历一次,所以深度优先遍历的时间复杂度是O(n+m),

n是节点数,m是边数

树的重心:

(深度优先遍历,可以算出每个子树所包含的节点个数)

#include
using namespace std;
const int N = 1e5 + 10;
int e[2 * N], ne[2 * N], idx; // 单链表
int h[N]; // 用邻接表, 来存树
int n, ans = N;
bool visited[N];
void add(int a, int b) 
{
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}

// 返回节点x所在子树的节点个数
int dfs(int x) 
{
    visited[x] = true;
    // sum 用来存 x 为根节点的子树的节点个数
    // res 来存, x 的子树的节点个数的最大值
    int sum = 1, res = 0;
    for(int i = h[x]; i != -1; i = ne[i]) 
    {
        int j = e[i]; // 取节点
        if(visited[j]) continue;
        int s = dfs(j);
        res = max(res, s);
        sum += s;
    }
    res = max(res, n - sum); 
    ans = min(ans, res);
    return sum;
}
int main() 
{
    memset(h, -1, sizeof h);
    scanf("%d", &n);
    for(int i = 1; i <= n - 1; i++) 
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);
        add(b, a);
    }
    dfs(1);
    printf("%d", ans);
    return 0;
}

树与图的存储

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

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

(2) 邻接表:

// 对于每个点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);
树与图的遍历
时间复杂度 O(n+m)O(n+m), nn 表示点数,mm 表示边数

时间复杂度 O(n+m), nn 表示点数,mm 表示边数

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

    // d[i] 存储点i的入度
    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];
            if (-- d[j] == 0)
                q[ ++ tt] = j;
        }
    }

    // 如果所有点都入队了,说明存在拓扑序列;否则不存在拓扑序列。
    return tt == n - 1;
}

拓扑排序
图的宽度优先搜索的应用,求拓扑序(拓扑序是针对有向图的)

什么是拓扑序:将一个图的很多节点,排成一个序列,使得图中的所有边,都是从前面的节点,指向后面的节点。则这样一个节点的排序,称为一个拓扑序。

若图中有环,则一定不存在拓扑序。

可以证明,一个有向无环图,一定存在一个拓扑序列。有向无环图,又被称为拓扑图。

对于每个节点,存在2个属性,入度和出度。

入度,即,有多少条边指向自己这个节点。

出度,即,有多少条边从自己这个节点指出去。

所有入度为0的点,可以排在当前最前面的位置。

算法流程:

将所有入度为0的点入队。
while(queue非空) 
{
    t = queue.pop(); // 获取队头
    枚举t的全部出边 t->j
      删掉边t->j, j节点的入度减一
      if(j的入度为0) 将j入队
}

一个有向无环图,一定存在至少一个入度为0的点

三、最短路

 常见的最短路问题,一般分为两大类:

单源最短路
多源汇最短路

在最短路问题中,源点也就是起点,汇点也就是终点。
单源最短路:指的是求一个点,到其他所有点的最短距离。(起点是固定的,单一的)

根据是否存在权重为负数的边,又分为两种情况:

所有边的权重都是正数,通常有两种算法

朴素Dijkstra:时间复杂度O(n2),其中n是图中点的个数,m是边的个数

堆优化版的Dijkstra:时间复杂度O(mlogn)

两者孰优孰劣,取决于图的疏密程度(取决于点数n,与边数m的大小关系)。当是稀疏图(n和m是同一级别)时,可能堆优化版的Dijkstra会好一些。当是稠密图时(m和n2是同一级别),使用朴素Dijkstra会好一些。

存在权重为负数的边通常有两种算法

Bellman-Ford:时间复杂度O(nm)

SPFA:时间复杂度一般是O(m),最差O(nm),是前者的优化版,但有的情况无法使用SPFA,只能使用前者,比如要求最短路不超过k条边,此时只能用Bellman-Ford

多源汇最短路:求多个起点到其他点的最短路。(起点不是固定的,而是多个)

Floyd算法:(时间复杂度O(n3))

Acwing 第三章模板及详解(搜索与图论)_第1张图片

最短路问题的核心在于,把问题抽象成一个最短路问题,并建图。图论相关的问题,不侧重于算法原理,而侧重于对问题的抽象。

Dijkstra基于贪心,Floyd基于动态规划,Bellman-Ford基于离散数学。

算法的选用:通常来说,单源最短路的,如果没有负权重的边,用Dijkstra,有负权重边的,通常用SPFA,极少数用Bellman-Ford;多源最短路的,用Floyd。


朴素Dijkstra

时间复杂是 O(n2+m)O(n2+m), nn 表示点数,mm 表示边数


假设图中一共有n个点,下标为1~n。下面所说的某个点的距离,都是指该点到起点(1号点)的距离。

算法步骤如下,用一个集合s来存放最短距离已经确定的点。

初始化距离,d[1] = 0, d[i] = +∞。即,将起点的距离初始化为0,而其余点的距离当前未确定,用正无穷表示。

循环

每次从距离已知的点中,选取一个不在s集合中,且距离最短的点(这一步可以用小根堆来优化),遍历该点的所有出边,更新这些出边所连接的点的距离。并把该次选取的点加入到集合s中,因为该点的最短距离此时已经确定。

当所有点都都被加入到s中,表示全部点的最短距离都已经确定完毕

注意某个点的距离已知,并不代表此时这个点的距离就是最终的最短距离。在后续的循环中,可能用一条更短距离的路径,去更新。

int g[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路,如果不存在则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < n - 1; i ++ )
    {
        int t = -1;     // 在还未确定最短路的点中,寻找距离最小的点
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        // 用t更新其他点的距离
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);

        st[t] = true;
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

堆优化版dijkstra 

时间复杂度 O(mlogn)O(mlogn), nn 表示点数,mm 表示边数


堆可以自己手写(用数组模拟),也可以使用现成的(C++的STL提供了priority_queue,Java的JDK中提供了PriorityQueue)
特别注意,插入堆的操作,由于更新距离时,可能对一些距离已知的点进行更新(更新为更小的距离),此时不能因为这个点已经在堆中就不进行插入了,因为其距离已经变了,堆中原有的节点已经无效了,按理说,应该修改堆中对应节点的距离值,然后做调整,实际上,可以直接插入一个新的节点(此时对于同一个节点,堆中有两份),但没有关系,堆中的重复节点不会影响最终的结果。
 

typedef pair PII;

int n;      // 点的数量
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离,如果不存在,则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue, greater> heap;
    heap.push({0, 1});      // first存储距离,second存储节点编号

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

手写堆:

#include 
#include 
using namespace std;

const int N = 1e6, INF = 0x3f3f3f3f;

int h[N], e[N], w[N], ne[N], idx;

int d[N];

int hPos[N], hDis[N], hSize;

bool st[N];

int n, m, x, y, z;

void add(int x, int y, int z) 
{
	e[idx] = y;
	w[idx] = z;
	ne[idx] = h[x];
	h[x] = idx++;
}

void heap_swap(int i, int j) 
{
	swap(hPos[i], hPos[j]);
	swap(hDis[i], hDis[j]);
}

void up(int pos)
{
	while(pos > 1 && hDis[pos / 2] > hDis[pos])
    {
		heap_swap(pos / 2, pos);
		pos /= 2;
	}
}

void down(int pos)
{
	int mx = pos;
	if(2 * pos <= hSize && hDis[2 * pos] < hDis[mx]) mx = 2 * pos;
	if(2 * pos + 1 <= hSize && hDis[2 * pos + 1] < hDis[mx]) mx = 2 * pos + 1;
	if(mx != pos) 
    {
		heap_swap(mx, pos);
		down(mx);
	}
}

void insert_to_heap(int x, int dis) 
{
	hSize++;
	hPos[hSize] = x;
	hDis[hSize] = dis;
	up(hSize);
}

void dijkstra() 
{
	d[1] = 0;
	insert_to_heap(1, 0);

	// 当堆非空时,执行
	while(hSize > 0) 
    {
		int x = hPos[1];
		heap_swap(1, hSize--);
		down(1);
		if(st[x]) continue; // 由于堆中可能存在重复的节点, 需要判断, 否则会超时
		st[x] = true; // 拿出来后, 该点的距离就已经确定
		for(int j = h[x]; j != -1; j = ne[j]) 
        {
			int u = e[j];
			if(d[u] > d[x] + w[j]) 
            {
				d[u] = d[x] + w[j];
				insert_to_heap(u, d[u]);
			}
		}
	}
}

int main() 
{
	memset(h, -1, sizeof h);
	memset(d, 0x3f, sizeof d);
	scanf("%d%d", &n, &m);
	while(m--) 
    {
		scanf("%d%d%d", &x, &y, &z);
		add(x, y, z);
	}
	dijkstra();
	if(d[n] == INF) printf("-1");
	else printf("%d", d[n]);
}

Bellman-Ford算法 

算法思路:

循环n次

每次循环,遍历图中所有的边。对每条边(a, b, w),(指的是从a点到b点,权重是w的一条边)更新d[b] = min(d[b], d[a] + w)

可以定义一个类,或者C++里面的结构体,存储a,b,w。表示存在一条边a点指向b点,权重为w)。则遍历所有边时,只要遍历全部的结构体数组即可

循环的次数的含义:假设循环了k次,则表示,从起点,经过不超过k条边,走到每个点的最短距离。

该算法能够保证,在循环n次后,对所有的边(a, b, w),都满足d[b] <= d[a] + w。这个不等式被称为三角不等式。上面的更新操作称为松弛操作。

该算法适用于有负权边的情况。

注意:如果有负权回路的话,最短路就不一定存在了。(注意是不一定存在)。当这个负权回路处于1号点到n号点的路径上,则每沿负权回路走一圈,距离都会减少,则可以无限走下去,1到n的距离就变得无限小(负无穷),此时1号点到n号点的最短距离就不存在。而如果负权回路不在1号点到n号点的路径上,则1到n的最短距离仍然存在。

该算法可以求出来,图中是否存在负权回路。如果迭代到第n次,还会进行更新,则说明存在一条最短路,路径上有n条边,n条边则需要n + 1个点,而由于图中一共只有n个点,所以这n + 1个点中一定有2个点是同一个点,则说明这条路径上有环;有环,并且此次进行了更新,说明这个环的权重是负的(只有更新后总的距离变得更小,才会执行更新)。

但求解负权回路,通常用SPFA算法,而不用Bellman-Ford算法,因为前者的时间复杂度更低。

由于循环了n次,每次遍历所有边(m条边)。故Bellman-Ford算法的时间复杂度是O(n×m),nn 表示点数,mm 表示边数
注意在模板题中需要对下面的模板稍作修改,加上备份数组,详情见模板题。

模板:

int n, m;       // n表示点数,m表示边数
int dist[N];        // dist[x]存储1到x的最短路距离

struct Edge     // 边,a表示出点,b表示入点,w表示边的权重
{
    int a, b, w;
}edges[M];

// 求1到n的最短路距离,如果无法从1走到n,则返回-1。
int bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    // 如果第n次迭代仍然会松弛三角不等式,就说明存在一条长度是n+1的最短路径,由抽屉原理,路径中至少存在两个相同的点,说明图中存在负权回路。
    for (int i = 0; i < n; i ++ )
    {
        for (int j = 0; j < m; j ++ )
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            if (dist[b] > dist[a] + w)
                dist[b] = dist[a] + w;
        }
    }

    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    return dist[n];
}

SPFA 算法(队列优化的Bellman-Ford算法) 


若要使用SPFA算法,一定要求图中不能有负权回路。只要图中没有负权回路,都可以用SPFA,这个算法的限制是比较小的。

SPFA其实是对Bellman-Ford的一种优化。

它优化的是这一步:d[b] = min(d[b], d[a] + w)

我们观察可以发现,只有当d[a]变小了,才会在下一轮循环中更新d[b]

考虑用BFS来做优化。用一个队列queue,来存放距离变小的节点。

(和Dijkstra很像)

SPFA的好处:能解决无负权边的问题,也能解决有负权边的问题,并且效率还比较高。但是当需要求在走不超过k条边的最短路问题上,就只能用Bellman-Ford算法了。

时间复杂度 平均情况下 O(m),最坏情况下 O(nm), nn 表示点数,mm 表示边数

模板:

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储每个点到1号点的最短距离
bool st[N];     // 存储每个点是否在队列中

// 求1号点到n号点的最短路距离,如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])     // 如果队列中已存在j,则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

spfa判断图中是否存在负环 
时间复杂度是 O(nm), nn 表示点数,mm 表示边数

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离,cnt[x]存储1到x的最短路中经过的点数
bool st[N];     // 存储每个点是否在队列中

// 如果存在负环,则返回true,否则返回false。
bool spfa()
{
    // 不需要初始化dist数组
    // 原理:如果某条最短路径上有n个点(除了自己),那么加上自己之后一共有n+1个点,由抽屉原理一定有两个点相同,所以存在环。

    queue q;
    for (int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;       // 如果从1号点到x的最短路中包含至少n个点(不包括自己),则说明存在环
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}

Floyd算法


求解多源汇最短路问题,也能处理边权为负数的情况,但是无法处理存在负权回路的情况。

使用邻接矩阵来存储图。初始使用d[i][j]来存储这个图,存储所有的边

算法思路:三层循环

for(k = 1; k <= n; k++)

​ for(i = 1; i <= n; i++)

​ for(j = 1; j <= n; j++)

​ d[i,j] = min(d[i,j] , d[i,k] + d[k,j])

循环结束后,d[i][j]存的就是点i到j的最短距离。

原理是基于动态规划(具体原理在后续的动态规划章节再做详解)。

其状态表示是:d(k, i, j),从点i,只经过1 ~ k这些中间点,到达点j的最短距离
 

时间复杂度是 O(n3), nn 表示点数

模板:

初始化:
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

// 算法结束后,d[a][b]表示a到b的最短距离
void floyd()
{
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

总结

Dijkstra

只适用于边权为正的情况。是从点的维度出发,每次循环确定起点到某一个点的最短距离,循环n次,则确定全部n个点到起点的最短距离。其思想有点类似BFS或者贪心,每次选一个距离最小的点,很保守的一点点地往外扩张,而不像DFS一条路走到黑。

注意有一个集合s的概念,每轮循环确定了一个点的最短距离后,就把这个点加入集合s。集合s表示的就是当前哪些点已经确定了最短距离了。已经确定了的点,之后的循环就不再考虑它们了。

每次循环,从未确定最短距离的点中,找一个距离最小的点a,则点a的最短距离已经确定,将其加入集合s,随后用a点去更新其他点(准确的说是和a相连的那些点(a的出边))的距离,本轮循环结束。

实际代码中,我们用一个布尔类型的数组,来表示一个点是否加入了集合s

堆优化版的Dijkstra:优化的就是每轮循环,选择一个距离最小的点这一步,使用小根堆可以在O(1)的时间复杂度选出距离最小的点

在选取一个距离最小的点后,只需要更新这个点所有出边,连接的那些点即可。所以用邻接表来存储比较合适。而邻接表适合存储稀疏图。所以在稀疏图时,可以采用堆优化Dijkstra,使用邻接表来存储图。稠密图的情况,则选用朴素Dijkstra,使用邻接矩阵来存储图。

朴素Dijkstra的时间复杂度是O(n2),堆优化Dijkstra的时间复杂度是O(mlogn)

Bellman-Ford

适用于存在负权边的情况。是从边的维度出发。首先还是初始化所有点的距离为正无穷,然后初始化起点的距离为0。

循环n次(准确地说应该是n-1次,因为只需要走n-1条边就能从1号点走到n号点),每次循环遍历所有的边(一个边用[a, b, w]表示,a点到b点,权重为w),每次更新这条边右端点(b点)的距离。d[b] = min(d[b], d[a] + w)。

其实只有当d[a]不是正无穷时,才需要更新。如果无脑更新,则当d[a]是正无穷,且w是负数的话,d[b]会被更新为一个比正无穷稍小一点的数,在实际编码中可能出错。而由于d[a]为正无穷(a点不可达),则其实b点应该也保持为正无穷(b点也不可达)。

Bellman-Ford可以用来求解,经过不超过k条边的最短距离。因为每次迭代,都是把边往前走了一步(对于那些a点不可达的边[a, b, w],不更新d[b])。需要注意,更新距离数组d时,需要提前备份一下d,并使用上一轮的备份来进行更新。这是为了防止串联更新的情况。

串联更新,就比如有3个点,2条边,a -> b -> c,则第一次循环时,先根据[a, b]这条边更新了d[b],然后访问到[b ,c]这条边时又会更新d[c],但第一次循环时,只走出去一条边,是不应当走到c点的。但如果直接使用d数组来更新,则访问[b ,c]这条边时,由于先前访问[a, b]时更新了d[b],则这次使用了新的d[b],则会更新d[c]。

串联更新会影响【第k次循环,找到不超过k条边的最短距离】这一语义。虽然它不会影响最终的最短距离。

另外,更新时的条件判断还要注意,需要特别关注重边的情况,说明如下

void bellman_ford() 
{
    // 循环k次
    for(int i = 0; i < k; i++) 
   {
        // 使用备份数组来进行更新, 以避免出现串联更新的情况, 串联更新会影响k次循环找到经过不超过k条边的最短距离的语义
        memcpy(tmp, d, sizeof d);
        // 每次枚举全部边
        for(int j = 0; j < m; j++) 
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            if(tmp[a] != INF && d[b] > tmp[a] + w) 
            {
                // 注意这里后面要用 d[b] > tmp[a] + w
                // 而不能用        tmp[b] > tmp[a] + w  
                // 当a和b存在重边时, 需要保证用到的是最短的那条边
                // 如果采用 tmp[b] > tmp[a] + w , 则无法保证这一点, 可自行验证
                d[b] = tmp[a] + w;
            }
        }
    }
}

Bellman-Ford也能用来判断图中是否存在负权回路。上面说了,实际只需要循环n-1次,若第n次循环仍然执行了距离的更新,则说明,从1号点到另一个点的最短距离,经过了n条边,n条边,则路径上有n+1个点,而由于一共只有n个点,所以这n+1个点中一定有2个点相同,则这条最短距离的路径上存在一个环,并且只有当距离变小时,才会执行更新,那么说明这个环的权重是负的。

SPFA

SPFA是对Bellman-Ford的优化。上面我们知道,Bellman-Ford是每次遍历所有边,并更新d[b] = min(d[b], d[a] + w)。

初始时所有点的距离都是正无穷的,而根据上面的式子,一条边的w是不变的,则只有当一条边的a点的距离d[a]变小了,下一轮循环才有可能会更新d[b]。于是我们只需要关注那些距离变小的点即可。

则采用类似BFS的思路,使用一个队列来保存那些距离变小的点。其代码思路相比Bellman-Ford而言,非常简单。所以通常对于存在负权边的最短路问题,通常直接用SPFA(甚至不存在负权边的问题,也可以用SPFA)。只有当类似于【求不超过k条边的最短路问题】时,才需要用Bellman-Ford。

**但是!SPFA无法用于存在负权回路的情况!**因为SPFA是用一个队列来存储距离变小的点,若存在负权回路,则队列永远不会为空,会无限循环。而Bellman-Ford由于只循环n次,即使有负权回路,也不会出现死循环。

SPFA代码

void spfa() 
{
    memset(d, 0x3f, sizeof d); // 距离初始化为正无穷
    d[1] = 0; // 起点距离为0
    q[++tt] = 1; // 起点距离变小, 入队
    while(tt >= hh) 
    { // 当队列不空
        int u = q[hh++]; // pop 队头
        // 遍历所有出边, 进行可能的更新
        for(int i = h[u]; i != -1; i = ne[i]) 
        {
            int j = e[i];
            if(d[j] > d[u] + w[i]) 
            { 
                // 一定要写这个判断, 因为d[a]变小后, 对于边[a, b, w], 不一定会保证d[b]也变小(可能b点有其他更短的路径)
                d[j] = d[u] + w[i];
                q[++tt] = j; // j点距离变小了, 入队
            }
        }
    }
}

四、最小生成树:


什么是最小生成树?首先,给定一个节点数是n,边数是m的无向连通图G。

则由全部的n个节点,和n-1条边构成的无向连通图被称为G的一颗生成树,在G的所有生成树中,边的权值之和最小的生成树,被称为G的最小生成树。

有两种常用算法:

Prim算法(普利姆)

    1.  朴素版Prim(时间复杂度O(n2),适用于稠密图)
    2.  堆优化版Prim(时间复杂度O(mlogn),适用于稀疏图)
Kruskal算法(克鲁斯卡尔)

适用于稀疏图,时间复杂度O(mlogm)

对于最小生成树问题,如果是稠密图,通常选用朴素版Prim算法,因为其思路比较简洁,代码比较短,如果是稀疏图,通常选用Kruskal算法,因为其思路比Prim简单清晰。堆优化版的Prim通常不怎么用。

Acwing 第三章模板及详解(搜索与图论)_第2张图片

对于最小生成树问题,如果是稠密图,通常选用朴素版Prim算法,因为其思路比较简洁,代码比较短,如果是稀疏图,通常选用Kruskal算法,因为其思路比Prim简单清晰。堆优化版的Prim通常不怎么用。

朴素版prim算法 

其算法流程如下

(其中用集合s表示,当前已经在连通块中的所有的点)

初始化距离, 将所有点的距离初始化为+∞

n次循环
      t <- 找到不在集合s中, 且距离最近的点
      用t来更新其他点到集合s的距离
      将t加入到集合s中
 

注意,一个点t到集合s的距离,指的是:若点t和集合s中的3个点有边相连。则点t到集合s的距离就是,t与3个点相连的边中,权重最小的那条边的权重。
时间复杂度是 O(n2+m)O(n2+m), nn 表示点数,mm 表示边数

模板:

int n;      // n表示点数
int g[N][N];        // 邻接矩阵,存储所有边
int dist[N];        // 存储其他点到当前最小生成树的距离
bool st[N];     // 存储每个点是否已经在生成树中


// 如果图不连通,则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim()
{
    memset(dist, 0x3f, sizeof dist);

    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        if (i && dist[t] == INF) return INF;

        if (i) res += dist[t];
        st[t] = true;

        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
    }

    return res;
}

Kruskal算法 

基本思路:

先将所有边,按照权重,从小到大排序

从小到大枚举每条边(a,b,w)

若a,b不连通,则将这条边,加入集合中(将a点和b点连接起来)

Kruskal算法初始时,相当于所有点都是独立的,没有任何边。

Kruskal不需要用邻接表或者邻接矩阵来存图,只需要存所有边就可以了

时间复杂度是 O(mlogm)O(mlogm), nn 表示点数,mm 表示边数

模板:

int n, m;       // n是点数,m是边数
int p[N];       // 并查集的父节点数组

struct Edge     // 存储边
{
    int a, b, w;

    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[M];

int find(int x)     // 并查集核心操作
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int kruskal()
{
    sort(edges, edges + m);

    for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集

    int res = 0, cnt = 0;
    for (int i = 0; i < m; i ++ )
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        a = find(a), b = find(b);
        if (a != b)     // 如果两个连通块不连通,则将这两个连通块合并
        {
            p[a] = b;
            res += w;
            cnt ++ ;
        }
    }

    if (cnt < n - 1) return INF;
    return res;
}

总结
与最短路的算法思想类似,求解最小生成树的算法,也是分别从点的维度与边的维度出发

Prim

思想有点类似最短路中的Dijkstra。从点的维度出发,使用一个集合s来表示当前已纳入连通块的点。用d[i]来表示节点i与集合s的距离。注意,一个节点i与一个连通块的距离,指的是,这个节点到连通块中任意点的边权的最小值。

假设连通块中已经有了3个点a, b, c,现在有一个点d,它与a有一条边相连,且边权为4,与b的边权为6,与c的边权为2。则d与这个连通块的距离就是2。

初始时,连通块s中没有点,为空。所有点到连通块s的距离初始化为+∞。我们先随便选一个点(比如1号点),将d[1]设为0,表示这个点到连通块s的距离为0,从这个点开始扩展,建立最小生成树。

循环n次,每次选取一个与连通块距离最小的点,将该点加入连通块s,并通过这个点的出边,去更新其他点到连通块的距离。

即,每次选择一个点,加入到最小生成树。每次选择哪个点呢,选择与当前连通块距离最小的点。

一个点的加入伴随着一条边的加入(除了第一个点)。

所以最终只要加入了n-1条边,就表明n个点已经全部加入了连通块,最小生成树构建完成。

实际代码中,也是通过一个布尔数组,来维护每个点是否已计入连通块。

其实某个点i到连通块的距离d[i],一定是这个点到连通块中某个点的边,且一定是边权最小的那个边。所以这样就能保证,每次迭代加入一个点到连通块中,都是以最小的代价(最小权重的边)将这个点加入到连通块中的。所以最终就能保证得到的连通块是最小生成树。

Kruskal

从边的维度出发,先将全部边按照权重从小到大排序。然后遍历全部边,每次查看这条边的左右两个端点,是否处于同一个连通块。若不是,则将这条边加入到最小生成树中,并把两个端点放入到同一连通块。这样,当遍历完全部的边之后,会尽可能地将所有点加入到同一个连通块中。且每次是仅当两个点不在连通块时,才将这条边加入,而边是从小到大排序的。这样就能保证尽可能以小的代价,来构造生成树。所以最终得到的就是最小生成树。

注意kruskal的算法流程中,为了确定2个点是否处于同一连通块,需要用到并查集。

五、二分图:染色法、匈牙利算法

二分图指的是,可以将一个图中的所有点,分成左右两部分,使得图中的所有边,都是从左边集合中的点,连到右边集合中的点。而左右两个集合内部都没有边。图示如下

Acwing 第三章模板及详解(搜索与图论)_第3张图片

这一节讲了2部分内容,分别是染色法匈牙利算法

Acwing 第三章模板及详解(搜索与图论)_第4张图片

图论中的一个重要性质:一个图是二分图,当且仅当图中不含奇数环

奇数环,指的是这个环中边的个数是奇数。(环中边的个数和点的个数是相同的)

在一个环中,假设共有4个点(偶数个),由于二分图需要同一个集合中的点不能互相连接。

则1号点属于集合A,1号点相连的2号点就应当属于集合B,2号点相连的3号点应当属于集合A,3号点相连的4号点应当属于集合B。4号点相连的1号点应当属于集合A。这样是能够二分的。

而若环中点数为奇数,初始时预设1号点属于集合A,绕着环推了一圈后,会发现1号点应当属于集合B。这就矛盾了。所以存在奇数环的话,这个图一定无法二分。

可以用染色法来判断一个图是否是二分图,使用深度优先遍历,从根节点开始把图中的每个节点都染色,每个节点要么是黑色要么是白色(2种),只要染色过程中没有出现矛盾,说明该图是一个二分图,否则,说明不是二分图。

 染色法判别二分图 

其中染色法是通过深度优先遍历实现
时间复杂度是 O(n+m), nn 表示点数,mm 表示边数

int n;      // n表示点数
int h[N], e[M], ne[M], idx;     // 邻接表存储图
int color[N];       // 表示每个点的颜色,-1表示未染色,0表示白色,1表示黑色

// 参数:u表示当前节点,c表示当前点的颜色
bool dfs(int u, int c)
{
    color[u] = c;
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (color[j] == -1)
        {
            if (!dfs(j, !c)) return false;
        }
        else if (color[j] == c) return false;
    }

    return true;
}

bool check()
{
    memset(color, -1, sizeof color);
    bool flag = true;
    for (int i = 1; i <= n; i ++ )
        if (color[i] == -1)
            if (!dfs(i, 0))
            {
                flag = false;
                break;
            }
    return flag;
}

匈牙利算法

时间复杂度是 O(nm), nn 表示点数,mm 表示边数


匈牙利算法,是给定一个二分图,用来求二分图的最大匹配的。

给定一个二分图G,在G的一个子图M中,M的边集中的任意两条边,都不依附于同一顶点,则称M是一个匹配。就是每个点只会有一条边相连,没有哪一个点,同时连了多条边。

所有匹配中包含边数最多的一组匹配,被称为二分图的最大匹配。其边数即为最大匹配数

匈牙利算法的核心思想是:我们枚举左半边所节点,每次找到这个节点连接的所有右侧的节点,遍历这些节点,1、当右侧的节点没有和其他左侧节点配对时,直接将这个节点和此时的左边节点配对。则该左侧节点配对成功。2、当右侧节点已经和其他左侧节点配对了,则尝试给这个右侧节点所配对的左侧节点,找一个备用节点。如果这个右侧节点所配对的左侧节点有其他可选择的备用节点。则将这个左侧节点和其备用节点配对。然后将这个右侧节点和当前节点配对。如此找下去…

模板:

int n1, n2;     // n1表示第一个集合中的点数,n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx;     // 邻接表存储所有边,匈牙利算法中只会用到从第一个集合指向第二个集合的边,所以这里只用存一个方向的边
int match[N];       // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
bool st[N];     // 表示第二个集合中的每个点是否已经被遍历过

bool find(int x)
{
    for (int i = h[x]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])
        {
            st[j] = true;
            if (match[j] == 0 || find(match[j]))
            {
                match[j] = x;
                return true;
            }
        }
    }

    return false;
}

// 求最大匹配数,依次枚举第一个集合中的每个点能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n1; i ++ )
{
    memset(st, false, sizeof st);
    if (find(i)) res ++ ;
}

小结

二分图相关的算法主要有2个

  • 染色法:是用来判断一个图是否是二分图的
  • 匈牙利算法:是用来求二分图的最大匹配的

你可能感兴趣的:(c++,深度优先,图论)