V - Sightseeing trip(Floyd求最小环)

大致题意 : 图中存在一个包含至少3个点的环, 如 i-->k-->j-->.....(若干点)-->i,  找到一个这样的最小环, 并输出路径

思路 : 可以利用Floyd算法做两次最短路, 一次找到j->i的最短路, 另一次通过k来更新i->k->j找到最小环, 用一个数记录最小值判断最小环是否存在, 路径可以用一个数组pos[i][j], 来记录i->j的中转点k, 通过递归迭代求出环的路径

AC代码如下:

#include <iostream>
#include <cstring>
#include <cstdio>
#include <string>
#include <iterator>
#include <cmath>
#include <algorithm>
#include <sstream>
#include <map>
#include <stack>
#include <set>
#include <queue>
#include <iomanip>
using namespace std;

stringstream ss;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 110;
const int INF = 0x3f3f3f3f;

int n,m;
int d[N][N], g[N][N];
int pos[N][N];
int path[N], cnt;
int res = INF;

void getpath(int a, int b)
{
    if(!pos[a][b]) return;

    int k = pos[a][b];
    getpath(a, k);
    path[cnt++] = k;
    getpath(k, b);
}
void floyd()
{
    for(int i = 1; i<=n; i++)
        for(int j = 1; j<=n; j++) d[i][j] = g[i][j];

    for(int k = 1; k<=n; k++)
    {
        // 求最小环(用i,j的最短路更新最小环)
        for(int i = 1; i<k; i++)
        {
            for(int j = i+1; j<k; j++)
            {
                if((ll)g[i][k]+g[k][j]+d[j][i] < res)
                {
                    res = g[i][k]+g[k][j]+d[j][i];
                    cnt = 0;
                    // 获取最小环的路径
                    path[cnt++] = k;
                    path[cnt++] = i;
                    // 寻找i,j的最短路中经过的点
                    getpath(i, j);
                    path[cnt++] = j;
                }
            }
        }

        // 求最短路
        for(int i = 1; i<=n; i++)
        {
            for(int j = 1; j<=n; j++)
            {
                if(d[i][j] > d[i][k]+d[k][j])
                {
                    d[i][j] = d[i][k]+d[k][j];
                    pos[i][j] = k;
                }
            }
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i = 1; i<=n; i++)
    {
        for(int j = 1; j<=n; j++)
        {
            g[i][j] = i == j ? 0 : INF;
        }
    }

    while(m -- )
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b] = min(c, g[a][b]);
        g[b][a] = g[a][b];
    }

    floyd();

    if(res == INF) cout<<"No solution."<<endl;
    else for(int i = 0; i<cnt; i++) cout<<path[i]<<" ";
}