题目：

http://acm.hdu.edu.cn/showproblem.php?pid=1599

题意：

Problem Description
杭州有N个景区，景区之间有一些双向的路来连接，现在8600想找一条旅游路线，这个路线从A点出发并且最后回到A点，假设经过的路线为V1,V2,….VK,V1,那么必须满足K>2,就是说至除了出发点以外至少要经过2个其他不同的景区，而且不能重复经过同一个景区。现在8600需要你帮他找一条这样的路线，并且花费越少越好。

Input
第一行是2个整数N和M（N <= 100, M <= 1000)，代表景区的个数和道路的条数。
接下来的M行里，每行包括3个整数a,b,c.代表a和b之间有一条通路，并且需要花费c元(c <= 100)。

Output
对于每个测试实例，如果能找到这样一条路线的话，输出花费的最小值。如果找不到的话，输出”It’s impossible.”.

Sample Input
3 3
1 2 1
2 3 1
1 3 1
3 3
1 2 1
1 2 3
2 3 1

Sample Output
3
It’s impossible.

思路：

求无向图最小环可以用floyd算法。floyd算法最外层循环执行到k时已求出以1~k-1为中间点的最短路径，无向图中一个环最少有三个点，设环中标号最大的顶点为w，跟w直接相连的两个点为v,u，则此最小环长度为dis[v][u] +g[v][w] + g[w][u]，dis[v][u]表示以1~k-1为中间节点时的最短路径，符合最外层循环k=w时的情况，之所以只求到以k-1为中间节点的最短路，是因为v到u的最短路中不能包含k，那么接下来枚举小于标号小于w的v、u两点的组合，即可求出最大标号为w的最小环的长度，当最外层循环结束时，就可以求出整个图的最小环。

#include <bits/stdc++.h>
using namespace std;

const int N = 110, INF = 1<<28;
int n, m;
int g[N][N], dis[N][N];

int floyd()
{
    int res = INF;
    for(int k = 1; k <= n; k++)
    {
        for(int i = 1; i < k; i++)
            for(int j = i+1; j < k; j++)
                res = min(res, dis[i][j] + g[i][k] + g[k][j]);
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
    }
    return res;
}
int main()
{
    while(~ scanf("%d%d", &n, &m))
    {
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                if(i == j) g[i][j] = dis[i][j] = 0;
                else g[i][j] = dis[i][j] = INF;
        for(int i = 1; i <= m; i++)
        {
            int v, u, c;
            scanf("%d%d%d", &v, &u, &c);
            g[v][u] = g[u][v] = dis[v][u] = dis[u][v] = min(g[v][u], c);
        }
        int res = floyd();
        if(res == INF) printf("It's impossible.\n");
        else printf("%d\n", res);
    }
    return 0;
}

另外这题还可以枚举两点，删除这两点的边，然后求两点间的最短路，环的长度即为两点间的最短路加上删除边的值，取最小的环长度即可，不过效率不高

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N = 110, INF = 0x3f3f3f3f;

struct edge
{
    int to, cost, next;
}g[N*N*2];

int dis[N], mpa[N][N];
bool vis[N];
int cnt, head[N];
inline void add_edge(int v, int u, int cost)
{
    g[cnt].to = u, g[cnt].cost = cost, g[cnt].next = head[v], head[v] = cnt++;
}
void spfa(int s, int t)
{
    queue<int> que;
    memset(dis, 0x3f, sizeof dis);
    memset(vis, 0, sizeof vis);
    que.push(s), dis[s] = 0, vis[s] = true;
    while(! que.empty())
    {
        int v = que.front(); que.pop();
        vis[v] = false;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if((v == s && u == t) || (v == t && u == s)) continue;
            if(dis[u] > dis[v] + g[i].cost)
            {
                dis[u] = dis[v] + g[i].cost;
                if(! vis[u]) que.push(u), vis[u] = true;
            }
        }
    }
}
int main()
{
    int n, m;
    while(~scanf("%d%d", &n, &m))
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        memset(mpa, 0x3f, sizeof mpa);
        int v[N*10], u[N*10], c[N*10];
        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d%d", &v[i], &u[i], &c[i]);
            mpa[v[i]][u[i]] = mpa[u[i]][v[i]] = min(mpa[v[i]][u[i]], c[i]);
        }
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                if(mpa[i][j] != INF) add_edge(i, j, mpa[i][j]);
        int res = INF;
        for(int i = 1; i <= n; i++)
            for(int j = i+1; j <= n; j++)
                if(mpa[i][j] != INF)
                {
                    spfa(i, j);
                    res = min(res, dis[j] + mpa[i][j]);
                }
        if(res == INF) printf("It's impossible.\n");
        else printf("%d\n", res);
    }
    return 0;
}