POJ 1734 无向图最小环/有向图最小环

给定一张图,求图中一个至少包含三个点的环,环上的点不重复,并且环上的边的长度之和最小.

点数不超过100个

输出方案

无向图:

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int MAXN = 3e2 + 5, MAXM = 2e5 + 5;
int a[MAXN][MAXN], d[MAXN][MAXN], pos[MAXN][MAXN];
int n, m;
int ans = 0x3f3f3f3f;
vector<int> path;
void get_path(int x, int y)
{
        if (pos[x][y] == 0)
        {
                return ;
        }
        get_path(x, pos[x][y]);
        path.push_back(pos[x][y]);
        get_path(pos[x][y], y);
}
int main()
{
        scanf("%d %d", &n, &m);
        mem(a, 0x3f);
        for (int i = 1; i <= n; i++)
        {
                a[i][i] = 0;
        }
        for (int i = 1; i <= m; i++)
        {
                int x, y, z;
                scanf("%d %d %d", &x, &y, &z);
                a[x][y] = a[y][x] = min(a[x][y], z);
        }
        memcpy(d, a, sizeof(a));
        for (int k = 1; k <= n; k++)
        {
                //刚开始循环时 d[i][j]表示经过编号不超过k-1的节点从i到j的最短路
                for (int i = 1; i < k; i++)
                {
                        for (int j = i + 1; j < k; j++)
                        {
                                if ((ll)d[i][j] + a[j][k] + a[k][i] < ans)
                                {
                                        ans = d[i][j] + a[j][k] + a[k][i];
                                        path.clear();
                                        path.push_back(i);
                                        get_path(i, j);
                                        path.push_back(j), path.push_back(k);
                                }
                        }
                }
                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;
                                }
                        }
                }
        }
        if (ans == 0x3f3f3f3f)
        {
                printf("No solution.
");
        }
        else
        {
                for (int i = 0; i < path.size(); i++)
                {
                        printf("%d ", path[i]);
                }
                printf("
");
        }
        return 0;
}

有向图:

有向图直接floyd求出最小的自身到自身的距离 即为答案(注意初始化全为INF)