问题概述

在图论中,我们会遇到这样一类问题:

在一个图中,定义环为这样的一条路径:

从起点$st$出发,经过图上任意数量的顶点且每个顶点至多经过一次,最后回到起点$st$的一个回路.

也就是说,在一个环里,除了顶点经过两次,其余的点只经过一次.我们这么定义环的大小:

一个环的大小指的是环回路上所有加权路径的权值和.

如下图,是两个环的例子:

左图可以理解为0->1->2->0,长度为7的环,这是个无向图;
右图可以理解为2->3->4->5->2,长度为2的环,这是个有向图.

显然,无论是有向图还是无向图,对于一个环,其起点可以是环上的任意点,如上图左可以看成是1->2->0->1,右可以看成是3->4->5->2->3,于是环的起点和表示是不确定的,但是环的大小是一定的.因此,我们不关心图上每一个点为起点的环的大小,因为可能不计其数,且有大量重复,我们只想知道:图上的最小环是多少?

常规解法

假设一个环中有一条$i\to j$的边,那么要构造一个相对于当前的$i$和$j$的最小环,应该在找一条不包括这条边的$i\to j$的最短路,加上这条边,就构成了环,显然,对于任意直接连通的两点都需要找这么一条最短路,这属于单源最短路,$Dijkstra$、$SPFA$、$Bellman-Ford$都可以做,具体做法如下:

1. 对于两个点$i,j$,若存在$i\to j$直连的路径$<i,j,w>$,则将设条路径权值$w$记录下来,再从图中删去;
2. 对于删去$<i,j,w>$的图,以$i$为源点跑一遍最短路径算法,得到$dis[j]$,再将$<i,j,w>$加回图中;
3. 将$w+dis[j]$和已求出来的最小环值比较,二者取小值作为新的最小环值;
4. 对于每条边,重复1至3,直到所有的边都删去过一次,算法结束.

注意事项: 从图中删去边可以将$<i,j,w>$改为$<i,j,+\infty >$,加回图中也是类似,做一个逆向操作.

分析: 对于这样的一个算法思路,时间瓶颈显然是在边的数目上,对于一个存在$E$条边的图,显然每次删除一条边,再跑一次最短路径,共需删除$E$次,执行$E$次最短路算法,因此整个算法的时间复杂度为:

• $O(E^{2}logE)$ -> (优先队列优化的$Dijkstra$)
• $O(V{E}^2)$ -> ($Bellman-Ford$)
• $O(V{E}^2)$(最坏) -> ($SPFA$)

由于这些解法的时间复杂度过高,尤其对于稠密图是无法接受的,一般用不到,因此实现就不在这里实现了.

Floyd-Warshall解法

为了解决传统解法时间复杂度过高的问题,这里可以使用$Floyd-Warshall$算法进行优化,如下:

假设一个环中,编号最大的顶点为$k$,和$k$相连的两个顶点为$i$、$j$,则这个环可以分为以下两部分:

1. $i\to k\to j$的路径,其中$i,j<k,i!=j$.
2. $i\to j$的路径,该路径不经过$k$.

显然对于1和2,如果$i\to j$的路径可以保证最短,那么这个环就可以对于当前的$i$和$j$保证最小.显然我们需要找一个$k$,我们不妨来看看$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]);

关于$Floyd-Warshall$算法,显而易见都是,对于外层循环,刚枚举第$L$层时,就已得到所有顶点之间的以$0...L-1$为中间点的最短路径,此时顶点$L$不在这些最短路径上.类比上面的环分为的1和2部分,我们不妨这么做:

1. 枚举到顶点$L$时,在进行下一步之前,枚举每一个$i、j,(i<L,j<L,i!=j)$.
2. 更新最小环的值: $mincircle=(mincircle,e[i][L]+e[L][j]+dis[i][j])$.

解释如下:

$e[V][V]$存的是最开始未改动的图,即原图的邻接矩阵.

$dis[i][j]$存的是最外层枚举到第$L$个点时,$i\to j$当前的最短路径.

显然$dis[i][j]$保存的是$i\to j$的,以$0...L-1$为中间点的最短路径,$e[i][L]+e[L][j]$表示一条$i\to L\to j$的路径权值(若不存在,则为$+\infty$),显然$e[i][L]+e[L][j]+dis[i][j]$表示一个编号最大的顶点为$k$的环,且$dis[i][j]$是一条不经过$k$的最短路,则这个环是条件"编号最大的顶点为$k$"下的最小环.如此一来,只要枚举每一个$k$,就能找到整个图的最小环.

上述算法只需要对$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;
}

这个改进算法的时间复杂度大概是$Floyd-Warshall$的两倍,去常数后认为他们相等,为$O(V^3)$,在稠密图中会有很大改进,是求最小环应用最广的算法.

注意: 初始化邻接矩阵时,$+\infty$的值要把握好,因为下列公式:

$mincircle=min(mincircle,e[i][k]+e[k][j]+dis[i][j])$

最坏可能出现出现3个$+\infty$相加,因此不要让$3\ast +\infty$超出了相应的数据范围.

这里使用1<<29​的值作为$+\infty$不会超过int范围,但是0x3f3f3f3f会超出int,请留心.