hdu5438 Ponds（并查集、拓扑排序）

题目链接：

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

题目大意：有p个池塘，每个池塘有个价值，他们之间有水管相连。如果一个池塘相连的水管少于2根，就可以被移除，否则不行。问最后直到不能再有池塘被移除的时候，所有池塘都组成的联通块中，数目为奇数的池塘的价值和。

思路：当池塘不能再被移除的时候，剩下的池塘肯定练成了环，所以我们要求的就是环的数目以及他们的权值和。可以利用并查集算出这个环里面的点的数目以及权值和。对于池塘的移除，其实就是把度小于2的点全部删去，其实就是拓扑排序。

我这里的是模拟度的删除，不是写拓扑排序的写法，不过效果一样（一开始没意识到是拓扑排序= =）

注意这里答案要用long long存，否则会Wa。

代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
queue<int>qu;
struct node {
  int to,next;
}edge[1000005];
int tot,head[100005];
int father[100005];
void add(int a,int b)
{
    edge[tot].to=b;
    edge[tot].next=head[a];
    head[a]=tot++;
}
int findroot(int x)
{
    int r=x;
    while(r!=father[r])
        r=father[r];
    return r;
}
int v[100005],a[100005],b[100005],indegree[100005],vis[100005];
    __int64 sum[100005],r[100005];
int main()
{
  int T,i,j,k,p,m;
    scanf("%d",&T);
    int f;
    while(T--)
    {
        f=0;
        tot=0;
        memset(indegree,0,sizeof(indegree));
        memset(head,-1,sizeof(head));
        memset(vis,0,sizeof(vis));
        scanf("%d%d",&p,&m);
        for(i=1;i<=p;i++)
        {
            scanf("%d",&v[i]);
        }
        for(i=1;i<=m;i++)
        {
            scanf("%d%d",&a[i],&b[i]);
            add(a[i],b[i]);
            add(b[i],a[i]);
            indegree[a[i]]++;
            indegree[b[i]]++;
        }
        f=1;
        while(f)
        {
            f=0;
            for(i=1;i<=p;i++)
        {
            if(vis[i])continue;
            if(indegree[i]<2)
                {
                    for(j=head[i];j!=-1;j=edge[j].next)
                        indegree[edge[j].to]--;
                if(indegree[i]==0)vis[i]=1;
            else {indegree[i]--;
            vis[i]=1;
            }
                f=1;
            }

        }
        }

        for(i=1;i<=p;i++)
        {
            father[i]=i;
            sum[i]=v[i];
            r[i]=1;

        }
        for(i=1;i<=m;i++)
        {
            if(!vis[a[i]]&&!vis[b[i]])
            {
                int fx=findroot(a[i]);
                int fy=findroot(b[i]);
                if(fx!=fy)
                {
                    father[fx]=fy;
                    sum[fy]+=sum[fx];
                    r[fy]+=r[fx];
                }
            }
        }
        __int64 ans=0;
        for(i=1;i<=p;i++)
        {
            if(father[i]==i&&!vis[i]&&r[i]%2)
            {
                ans+=sum[i];
            }
        }
        printf("%I64d\n",ans);
    }
}
/*
7
7 7
1 2 3 4 5 6 7
1 2
1 3
3 4
2 4
2 5
2 7
1 5
4 5
1 2 3 4
1 2
2 3
3 4
4 1
2 4
*/