求图的最小环

/*
floyd求图的最小环：O(n^3) 
对于无向图：
在flody外层循环至k时
我们求得了任意的i,j,允许经过[1...k-1]这些点的最短路径
如果此时对于任意的i,j,有g[k][i],dist[i][j],g[j][k]存在
且i,j,k两两不同,则说明存在一个k->i->j->k的一个环 
对于有向图：
只要初始化dist[i][j] = INF
跑一遍floyd,dist[i][i]即为一个环 
*/
#include <cstdio>
#include <algorithm>
using namespace std;
#define INF 0x3fffffff

int g[105][105];    //g[i][j] != INF表示i,j两个点有边 
int dist[105][105];

int floyd(int n)
{
	int res = INF;
	for (int k = 1; k <= n; k++)
	{
		//除去k点的那个环剩下的那条最短路中一定不能有k
		//所以先找环再松弛
		for (int i = 1; i <= n; i++)
		{
			for (int j = 1; j <= n; j++)
			{
				if( i == j || i == k || j == k ) continue;   //i,j,k必须不同 
				if( g[k][i] == INF || g[j][k] == INF || dist[i][j] == INF ) continue;  
				//路径必须都存在 
				res = min(res,g[k][i] + dist[i][j] + g[j][k]);  //求环 
			}
		}
		for (int i = 1; i <= n; i++)
		{
			for (int j = 1; j <= n; j++)
			{
				dist[i][j] = min(dist[i][j],dist[i][k]+dist[k][j]);
			}
		}
	}
	return res;
}

int main()
{
	int n,m;
	scanf("%d%d",&n,&m); 
	for (int i = 1; i <= n; i++)
	{ 
		for (int j = 1; j <= n; j++)
		{
			if( i == j ) dist[i][j] = 0;
			else dist[i][j] = INF;
			g[i][j] = INF;
		}
	}
	for (int i = 0; i < m; i++)
	{
		int x,y,v;
		scanf("%d%d%d",&x,&y,&v); 
		dist[x][y] = min(dist[x][y],v);   //可能有重边 
		dist[y][x] = dist[x][y];
		g[x][y] = g[y][x] = dist[x][y];
	}
	int ans = INF;
	ans = floyd(n);
	if( ans == INF ) printf("It's impossible.\n");
	else printf("%d\n",ans);
	return 0;
} 

其实当图为无权图时，求图的最小环有一种十分简单的方法。我们可以枚举一个点，然后以这个点为起点bfs，只要发现一个点被走了两次，那么就找到了以这个点为起点的最小环。这时候复杂度就可以降低到O(n^2)。

int bfs(int begin)
{
	queue<int> q;
	q.push(begin);
	dis[begin] = 0,pre[begin] = 0;
	int ans = 1e9;
	while( !q.empty() )
	{
		int x = q.front();
		q.pop();
		for (int i = 0; i < g[x].size(); i++)
		{
			int t = g[x][i];
			if( t == pre[x] ) continue;
			if( dis[t] != -1 ) 
			{
				ans = dis[x] + dis[t] + 1;
				break;
			}
			dis[t] = dis[x] + 1;
			pre[t] = x;
			q.push(t);
		}
		if( ans != 1e9 ) break;
	}
	return ans;
}