问题概述
在图论中,我们会遇到这样一类问题:
在一个图中,定义环为这样的一条路径:
从起点 s t st st出发,经过图上任意数量的顶点且每个顶点至多经过一次,最后回到起点 s t st st的一个回路.
也就是说,在一个环里,除了顶点经过两次,其余的点只经过一次.我们这么定义环的大小:
一个环的大小指的是环回路上所有加权路径的权值和.
如下图,是两个环的例子:
左图可以理解为0->1->2->0,长度为7的环,这是个无向图;
右图可以理解为2->3->4->5->2,长度为2的环,这是个有向图.
显然,无论是有向图还是无向图,对于一个环,其起点可以是环上的任意点,如上图左可以看成是1->2->0->1,右可以看成是3->4->5->2->3,于是环的起点和表示是不确定的,但是环的大小是一定的.因此,我们不关心图上每一个点为起点的环的大小,因为可能不计其数,且有大量重复,我们只想知道: 图上的最小环是多少?
常规解法
假设一个环中有一条 i → j i \to j i→j的边,那么要构造一个相对于当前的 i i i和 j j j的最小环,应该在找一条不包括这条边的 i → j i \to j i→j的最短路,加上这条边,就构成了环,显然,对于任意直接连通的两点都需要找这么一条最短路,这属于单源最短路, D i j k s t r a Dijkstra Dijkstra、 S P F A SPFA SPFA、 B e l l m a n − F o r d Bellman-Ford Bellman−Ford都可以做,具体做法如下:
- 对于两个点 i , j i,j i,j,若存在 i → j i \to j i→j直连的路径 < i , j , w > <i,j,w> <i,j,w>,则将设条路径权值 w w w记录下来,再从图中删去;
- 对于删去 < i , j , w > <i,j,w> <i,j,w>的图,以 i i i为源点跑一遍最短路径算法,得到 d i s [ j ] dis[j] dis[j],再将 < i , j , w > <i,j,w> <i,j,w>加回图中;
- 将 w + d i s [ j ] w + dis[j] w+dis[j]和已求出来的最小环值比较,二者取小值作为新的最小环值;
- 对于每条边,重复1至3,直到所有的边都删去过一次,算法结束.
注意事项: 从图中删去边可以将 < i , j , w > <i,j,w> <i,j,w>改为 < i , j , + ∞ > <i,j,+\infin> <i,j,+∞>,加回图中也是类似,做一个逆向操作.
分析: 对于这样的一个算法思路,时间瓶颈显然是在边的数目上,对于一个存在 E E E条边的图,显然每次删除一条边,再跑一次最短路径,共需删除 E E E次,执行 E E E次最短路算法,因此整个算法的时间复杂度为:
- O ( E 2 l o g E ) O(E^2logE) O(E2logE) -> (优先队列优化的 D i j k s t r a Dijkstra Dijkstra)
- O ( V E 2 ) O(VE^2) O(VE2) -> ( B e l l m a n − F o r d Bellman-Ford Bellman−Ford)
- O ( V E 2 ) O(VE^2) O(VE2)(最坏) -> ( S P F A SPFA SPFA)
由于这些解法的时间复杂度过高,尤其对于稠密图是无法接受的,一般用不到,因此实现就不在这里实现了.
Floyd-Warshall解法
为了解决传统解法时间复杂度过高的问题,这里可以使用 F l o y d − W a r s h a l l Floyd-Warshall Floyd−Warshall算法进行优化,如下:
假设一个环中,编号最大的顶点为 k k k,和 k k k相连的两个顶点为 i i i、 j j j,则这个环可以分为以下两部分:
- i → k → j i \to k \to j i→k→j的路径,其中 i , j < k , i ! = j i,j \lt k,i \ != j i,j<k,i !=j.
- i → j i \to j i→j的路径,该路径不经过 k k k.
显然对于1和2,如果 i → j i \to j i→j的路径可以保证最短,那么这个环就可以对于当前的 i i i和 j j j保证最小.显然我们需要找一个 k k k,我们不妨来看看 F l o y d − W a r s h a l l Floyd-Warshall Floyd−Warshall的结构:
for(int k = 0; k <= n; k++) //枚举每个中间点;
for(int i = 0; i <= n; i++) //枚举起始点;
for(int j = 0; j <= n; j++) //枚举结束点;
e[i][j] = min(e[i][j],e[i][k] + e[k][j]);
关于 F l o y d − W a r s h a l l Floyd-Warshall Floyd−Warshall算法,显而易见都是,对于外层循环,刚枚举第 L L L层时,就已得到所有顶点之间的以 0... L − 1 0...L-1 0...L−1为中间点的最短路径,此时顶点 L L L不在这些最短路径上.类比上面的环分为的1和2部分,我们不妨这么做:
- 枚举到顶点 L L L时,在进行下一步之前,枚举每一个 i 、 j , ( i < L , j < L , i ! = j ) i、j,(i \lt L,j \lt L,i \ != j) i、j,(i<L,j<L,i !=j).
- 更新最小环的值: m i n c i r c l e = ( m i n c i r c l e , e [ i ] [ L ] + e [ L ] [ j ] + d i s [ i ] [ j ] ) mincircle = (mincircle,e[i][L]+e[L][j]+dis[i][j]) mincircle=(mincircle,e[i][L]+e[L][j]+dis[i][j]).
解释如下:
e [ V ] [ V ] e[V][V] e[V][V]存的是最开始未改动的图,即原图的邻接矩阵.
d i s [ i ] [ j ] dis[i][j] dis[i][j]存的是最外层枚举到第 L L L个点时, i → j i \to j i→j当前的最短路径.
显然 d i s [ i ] [ j ] dis[i][j] dis[i][j]保存的是 i → j i \to j i→j的,以 0... L − 1 0...L-1 0...L−1为中间点的最短路径, e [ i ] [ L ] + e [ L ] [ j ] e[i][L] + e[L][j] e[i][L]+e[L][j]表示一条 i → L → j i \to L \to j i→L→j的路径权值(若不存在,则为 + ∞ +\infin +∞),显然 e [ i ] [ L ] + e [ L ] [ j ] + d i s [ i ] [ j ] e[i][L] + e[L][j] + dis[i][j] e[i][L]+e[L][j]+dis[i][j]表示一个编号最大的顶点为 k k k的环,且 d i s [ i ] [ j ] dis[i][j] dis[i][j]是一条不经过 k k k的最短路,则这个环是条件"编号最大的顶点为 k k k"下的最小环.如此一来,只要枚举每一个 k k k,就能找到整个图的最小环.
上述算法只需要对 F l o y d − W a r s h a l l Floyd-Warshall Floyd−Warshall进行适当改编,实现如下:
#include<iostream>
#include<cstring>
#include<algorithm>
#define maxn 10005
#define inf 1<<29
using namespace std;
int e[maxn][maxn],dis[maxn][maxn];
void init(int n) {
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= n; j++) {
if(i == j)
e[i][j] = dis[i][j] = 0;
else
e[i][j] = dis[i][j] = inf;
}
}
}
int Floyd(int n) {
int mincircle = inf;
for(int k = 0; k <= n; k++) {
for(int i = 0; i < k; i++) {
for(int j = i+1; j < k; j++) {
mincircle = min(mincircle,e[i][k]+e[k][j]+dis[i][j]); //最小环公式;
}
}
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= n; j++) {
dis[i][j] = min(dis[i][j],dis[i][k]+dis[k][j]); //正常Floyd;
}
}
}
return mincircle;
}
int main() {
int n,m,u,v,w,ans;
while(cin>>n>>m) {
init(n);
for(int i = 0; i < m; i++) {
cin>>u>>v>>w;
e[u][v] = dis[u][v] = w;
e[v][u] = dis[v][u] = w;
}
ans = Floyd(n);
if(ans == inf)
cout<<"No Solution!"<<endl;
else
cout<<ans<<endl;
}
return 0;
}
这个改进算法的时间复杂度大概是 F l o y d − W a r s h a l l Floyd-Warshall Floyd−Warshall的两倍,去常数后认为他们相等,为 O ( V 3 ) O(V^3) O(V3),在稠密图中会有很大改进,是求最小环应用最广的算法.
注意: 初始化邻接矩阵时, + ∞ +\infin +∞的值要把握好,因为下列公式:
m i n c i r c l e = m i n ( m i n c i r c l e , e [ i ] [ k ] + e [ k ] [ j ] + d i s [ i ] [ j ] ) mincircle = min(mincircle,e[i][k]+e[k][j]+dis[i][j]) mincircle=min(mincircle,e[i][k]+e[k][j]+dis[i][j])
最坏可能出现出现3个 + ∞ +\infin +∞相加,因此不要让 3 ∗ + ∞ 3*+\infin 3∗+∞超出了相应的数据范围.
这里使用1<<29的值作为 + ∞ +\infin +∞不会超过int范围,但是0x3f3f3f3f会超出int,请留心.