无向图的最小环问题

板子题目地址
夜深人静最适合静下心来写博客了哈哈。

写一下最小环问题的Floyd解法吧，时间复杂度在立方的水平（还行吧）， 做法和Floyd一样，只不过是在作Floyd的时候，多了点操作，我们的想法是将每次Floyd做法枚举的中间点k，作为环的最大点，为什么要这样做呢，因为这样做枚举的环中一定不会存在重复点，那么我们只需要做下边的操作 $res=dist[i]j]+map[j][k]+map[k][i]$ 其中 $i<k,j<k$ ， 这样做我们可以得到最大值吗，是可以的，我们最优答案的环中肯定会存在一个最大点，所以我们一定会枚举到最优答案的，在做的时候保存一下每个状态是从哪个状态转移过来的，这样就可以保存路径了，当然也可以进行枚举从而得到路径，不过这样会很慢。

注意下别忘了数据越界的问题（头疼）。
代码：

#include <iostream>
#include <cstring>
#include <vector>

using namespace std;


const int N = 110;

int map[N][N], parent [N][N], t[N][N];

vector <int> path;

void get (int l, int r)
{
    if (!parent[l][r]) return;
    get (l, parent[l][r]);
    path.push_back (parent[l][r]);
    get (parent[l][r], r);
    
}

int main()
{
    int n, m; scanf ("%d%d", &n, &m);
    memset (map, 0x3f, sizeof map);
    for (int i = 1; i <= m; i ++)
    {
        int a, b, c; scanf ("%d%d%d", &a, &b, &c);
        map[a][b] = map[b][a] = min (map[a][b], c);
    }
    
    memcpy (t, map, sizeof map);
    
    int  res = 1e9;
    for (int k = 1; k <= n; k ++)
    {
        for (int i = 1; i < k; i ++)
            for (int j = i + 1; j < k; j ++)
            {
                if (res > (long long)map[i][j] + t[j][k] + t[k][i])
                {
                    res = map[i][j] + t[i][k] + t[k][j];
                    path.clear();
                    path.push_back (i);
                    get (i, j);
                    path.push_back (j);
                    path.push_back (k);
                   // printf ("i == %d j == %d, k == %d res == %d \n", i, j, k, res);
                }
            }
        for (int i = 1; i <= n; i ++)
            for (int j = 1; j <= n; j ++)
            {
                if (map[i][j] > map[i][k] + map[k][j])
                {
                    map[i][j] = map[i][k] + map[k][j];
                    parent [i][j] = k;
                }
            }
    }        
    if (res == 1e9) puts ("No solution.");
    else 
    {
        for (int i = 0; i < path.size(); i ++) printf ("%d ", path[i]);    
    }
    
    return 0;
}