POJ 3164(最小树形图模板题)

参考地址：点击打开链接

最小树形图是从一个源点出发，选取一些边，使得能够从源点可以到达其他所有点，并且权和最小，即有向图的最小生成树。

算法步骤：

1.判断图的连通性，若不连通直接无解，否则一定有解。

2.为除了根节点以外的所有点选择一个权值最小的入边，假设用pre数组记录前驱，f数组记录选择的边长，记所选边权和为temp。

3.（可利用并查集）判断选择的的边是否构成环，若没有则直接ans+=temp并输出ans，若有，则进行下一步操作。

4.对该环实施缩点操作，设该环上有点V1，V2……Vi……Vn，缩成的点为node ，对于所有不在环中的点P进行如下更改：

（1） 点P到node的距离为min{a[p,Vi]-f[Vi]} (a为边集数组)

 （2）点node到p的距离为min{a[Vi,p]}

操作（1）的理解：先假设环上所有边均选上，若下次选择某一条边进入该环，则可以断开进入点与进入点的前驱之间的边，即断开F[进入点]，所以等效为直接把a[p,node]赋值为min{a[p,Vi]-f[Vi]}。

特别提醒：本题有自环，可以提前删掉，因为它没有用。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
using namespace std;
const int maxn = 100 + 7;
const int INF = ~0U >> 1;
double G[maxn][maxn];  // 图，不能到达设为INF
int n, m;
double x[maxn], y[maxn];
int p[maxn];   // 点的前驱
int vis[maxn];
bool in[maxn];  // 点是否被删掉

double Distance(double a, double b) {
    return sqrt(a * a + b * b);
}

void dfs(int u) {
    for(int i = 1; i <= n; ++i) {
        if(!vis[i] && G[u][i] < INF) {
            vis[i] = 1;
            dfs(i);
        }
    }
}

double slove(int u) {
    memset(vis, 0, sizeof(vis));
    vis[u] = 1;
    dfs(1);
    for(int i = 1; i <= n; ++i)
        if(!vis[i]) return -1;  // 图必须是联通的

    memset(vis, 0, sizeof(vis));
    memset(in, false, sizeof(in));

    for(int i = 1; i <= n; ++i) G[i][i] = INF;
    double ans = 0;

    while(true) {
        for(int i = 1; i <= n; ++i)  ///为除了根节点以外的所有点选择一个权值最小的入边
            if(i != u && !in[i]) {  ///除了根节点以及被删除的点
                p[i] = i;
                for(int j = 1; j <= n; ++j)
                    if(!in[j] && G[j][i] < G[p[i]][i])
                        p[i] = j;
            }

        bool ok = false;
        int i;
        for(i = 1; i <= n; ++i)  /// 判断是否有环
            if(i != u && !in[i]) {
                int cnt = 0, j = i;
                while(j != u && p[j] != i && cnt <= n) ++cnt, j = p[j];
                if(j == u || cnt > n) continue;  //没有环

                ok = true;  // 有环
                break;
            }

        if(!ok) {  //没有环，加和退出
            for(int i = 1; i <= n; ++i)
                if(i != u && !in[i]) ans += G[p[i]][i];
            return ans;
        }
        memset(vis, 0, sizeof(vis));
        int j = i;
        do {  /// 缩点 把环缩成i一个点
            ans += G[p[j]][j];
            vis[j] = 1;
            in[j] = 1;
            j = p[j];
        } while(i != j);
        in[i] = 0; /// 别忘了

        for(int k = 1; k <= n; ++k)  /// 修改距离
            if(vis[k]) {
                for(j = 1; j <= n; ++j)
                    if(vis[j] == 0) {
                        if(G[i][j] > G[k][j]) G[i][j] = G[k][j];
                        if(G[j][k] < INF && G[j][k] - G[p[k]][k] < G[j][i])
                            G[j][i] = G[j][k] - G[p[k]][k];
                    }
            }

    }
    return ans;
}

int main() {
    while(scanf("%d%d", &n, &m) != EOF) {
        for(int i = 1; i <= n; ++i)
            scanf("%lf%lf", &x[i], &y[i]);
        int u, v;
        for(int i = 0; i <= n; ++i)
            for(int j = 0; j <= n; ++j) G[i][j] = INF;
        for(int i = 1; i <= m; ++i) {
            scanf("%d%d", &u, &v);
            if(u == v) continue;  //去掉自环
            double d = Distance(x[u] - x[v], y[u] - y[v]);
            if(d < G[u][v]) G[u][v] = d;  // 重边选最小
        }
//        for(int i = 1; i <= n; ++i) {
//            for(int j = 1; j <= n; ++j)
//                printf("%.3f ", G[i][j]);
//            printf("\n");
//        }
        double ans = slove(1);
        if(ans >= 0) printf("%.2f\n", ans);
        else printf("poor snoopy\n");
    }
    return 0;
}