最小树形图【模板】

基于贪心和缩点的思想。
假设根的顶点是V0。
(1)除了根结点外，所有的点Vi，找到以Vi为终点的最短的边，加入集合中
（pre[v]存放的是终点v的起点,In[v]存放终点为v的最短的边）
(2)检查集合中有没有有向环和收缩点。若没有有向环和收缩点，结束计算；若没有有向环、但含收缩边，则跳至步骤(4)；若含有有向环，则跳至步骤(3)。Ps：如果出现重边，将忽略权值较高的
(3)含有有向环，则收缩有向环(缩点)，把有向环收缩为一个点，其有向环内的边被收缩掉，而环外的边被保
留，构建新图，重复步骤(1)、(2)。
(4)没有有向环，有收缩边，则展开收缩边。

如果没有固定根，就需要建立一个虚根。可以假设一个根结点，也就是虚根，虚根节点可以为N+1。让所有边都有虚根指向的边，权值大小看题目要求。
若要使每一个原节点都有可能当根，则是权值全部相等，且权值应大于所有边的总权值。如果虚根到每个点的权值和该点相关，则权值应为对应大小。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<limits.h>
using namespace std;
const int MAXN = 110;
const int MAXM = 10010;

struct Node//存放图
{
    int from;
    int to;
    double w;
}Edges[MAXM];

struct Node1
{
    double x;
    double y;
};
Node1 Point[MAXN];

double Dist(Node1 a, Node1 b)
{
    double x = a.x - b.x;
    double y = a.y - b.y;
    return sqrt(x*x+y*y);
}

int pre[MAXN],vis[MAXN],flag[MAXN];
//flag标记缩点，标记为true，则该点被缩掉
double In[MAXN],sum;

double ZhuLiu(int root,int N,int M)
{
    sum = 0;    //存放最小树形图
    while(true)
    {
        //求最短弧集合
        for(int i = 0; i < N; ++i)
            In[i] = INT_MAX;
        for(int i = 0; i < M; ++i)
        {
            int u = Edges[i].from;
            int v = Edges[i].to;
            if(Edges[i].w < In[v] && u != v)
            {
                pre[v] = u;//v为终点，pre[v]存放起点
                In[v] = Edges[i].w;//权值最小的边
            }
        }

        for(int i = 0; i < N; ++i)//如果存在除root以外的孤立点，则不存在最小树形图
        {
            if(i == root)
                continue;
            if(In[i] == INT_MAX)
                return -1;
        }
        int CntNode = 0;    //新图编号
        memset(flag,-1,sizeof(flag));
        memset(vis,-1,sizeof(vis));
        In[root] = 0;
        for(int i = 0; i < N; ++i)   //找环,标记每个环
        {
            sum += In[i];
            int v = i;
            while(vis[v]!=i && flag[v]==-1 && v!=root)//每个点寻找其前序点，要么最终寻找至根部，要么找到一个环
            {
                vis[v] = i;
                v = pre[v];
            }
            if(v != root && flag[v] == -1)  //新图重新编号
            {
                for(int u = pre[v]; u != v; u = pre[u])
                    flag[u] = CntNode;
                flag[v] = CntNode++;
            }
        }
        if(CntNode == 0)    //无环，跳出
            break;
        for(int i = 0; i < N; ++i)  //缩点
        {
            if(flag[i] == -1)
                flag[i] = CntNode++;
        }
        for(int i = 0; i < M; ++i)  //建立新图，更新其他点到环的距离
        {
            int v = Edges[i].to;
            Edges[i].from = flag[Edges[i].from];
            Edges[i].to = flag[Edges[i].to];
            if(Edges[i].from != Edges[i].to)
                Edges[i].w -= In[v];
        }
        N = CntNode;
        root = flag[root];
    }
    return sum;
}

int main()
{
    int x,y,N,M;
    while(~scanf("%d%d",&N,&M))
    {
        int id = 0;
        for(int i = 0; i < N; ++i)
            scanf("%lf%lf",&Point[i].x,&Point[i].y);
        for(int i = 0; i < M; ++i)
        {
            scanf("%d%d",&x,&y);
            if(x == y)
                continue;
            x--;
            y--;
            Edges[id].from = x;
            Edges[id].to = y;
            Edges[id++].w = Dist(Point[x],Point[y]);    //建立有向图
        }
        double ans = ZhuLiu(0,N,id);
        if(ans == -1)   //不能构成最小树形图
            printf("poor snoopy\n");
        else
            printf("%.2lf\n",ans);
    }
    return 0;
}