True Liars POJ - 1417（带权并查集+dp）不来看看么

True Liars POJ - 1417   点击打开链接

这题时kuangbin大大的并查集专题里面的，解法也是kuangbin大大的解法，但是加上了一点我的理解

题意：    给你p1个好人和p2个坏人，编号为1-p1+p2，然后给你n中操作

                   x1 x2 no：x1说x2不是好人

                  x1 x2 yes：x1说x2是好人

在这里好人说的总是对的，坏人说的总是坏的，然后问你最后能不能唯一确定哪些是好人，并输出，否则输出”no“

思路：首先，我们假设x1是好人，并且有      x1   x2  yes 那么，x2一定也是好人，如果有x1  x2  no 那么x2一定是坏人。如果假设x1是坏人，如果有x1   x2  no  那么 x2 一定是好人， 如果有  x1  x2  yes  那么x2也是坏人。也就是说， 只要给出的是yes，那么，x1，x2一定是同一类人，否则，一定不是同一类。（自己推一下其中的关系就会明白）。那么，根据这个关系，我们就可以用带权并查集来做了，令同一类为0，否则为1。但是，只用带权并查集的话，只能分出若干个大的集合，每个大的集合又分成两个小集合，即 好人集合 与 坏人集合。但是，我们并不知道每个大集合中，哪个小集合是好人集合哪个集合是坏人集合。这时，就需要我们用dp来处理了。 从每个大集合里面取一个当作好人集合，判断方案是否唯一 。dp[i][j]表示，前i个大集合有j个好人时的方案的个数，最后，只需判断 对应大集合个数和好人个数时的方案数是否为1即可，不唯一，说明不能确定。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int Max=605;
int a[Max][2];//a[i][0],a[i][1]表示每个大集合分成两部分的个数即相同和不同
vector<int> b[Max][2];//三维，记录大集合，小集合，以及集合里面元素的编号
bool used[Max];//记录是否在集合里
int dp[Max][Max/2];
int pre[Max][Max/2];//记录上一个状态的好人个数
struct node
{
    int par,relation;
};
node p[Max];
int n,p1,p2,m;
void init()
{
    for(int i=1;i<=m;i++){
        p[i].par=i;
        p[i].relation=0;
    }
    for(int i=0;i<Max;i++){
        b[i][0].clear();
        b[i][1].clear();
        a[i][0]=0;
        a[i][1]=0;
    }
}
int Find(int x)
{
    if(x==p[x].par)
        return x;
    int tmp=p[x].par;
    p[x].par=Find(tmp);
    p[x].relation=(p[x].relation+p[tmp].relation)%2;//关系域转换方程
    return p[x].par;
}
void unite(int x,int y,int c)
{
    int root1=Find(x);
    int root2=Find(y);
    if(root1!=root2){
        p[root2].par=root1;
        p[root2].relation=(2-p[x].relation+c+p[y].relation)%2;//关系域转换方程
    }
}
int main()
{
    int u,v,w;
    char str[10];
    while(~scanf("%d%d%d",&n,&p1,&p2)&&(n+p1+p2)){
        m=p1+p2;
        init();
        for(int i=0;i<n;i++){
            scanf("%d%d%s",&u,&v,str);
            if(str[0]=='y')
                w=0;
            else
                w=1;
            unite(u,v,w);
        }
        memset(used,0,sizeof(used));
        int cnt=1;//记录大集合的个数
        for(int i=1;i<=m;i++)
            if(!used[i]){
                int tmp=Find(i);
                for(int j=i;j<=m;j++){
                    if(Find(j)==tmp){
                        used[j]=true;
                        b[cnt][p[j].relation].push_back(j);
                        a[cnt][p[j].relation]++;
                    }
                }
            cnt++;
        }
        memset(dp,0,sizeof(dp));
        dp[0][0]=1;
        for(int i=1;i<cnt;i++){//前i个集合里面，如果有j个好人的方案
            for(int j=p1;j>=0;j--){
                if(j-a[i][0]>=0 && dp[i-1][j-a[i][0]]){//如果人数足够，并且上一状态有满足方案（即保证可以组成一个合法方案）
                    dp[i][j]+=dp[i-1][j-a[i][0]];
                    pre[i][j]=j-a[i][0];
                }
                if(j-a[i][1]>=0 && dp[i-1][j-a[i][1]]){
                    dp[i][j]+=dp[i-1][j-a[i][1]];
                    pre[i][j]=j-a[i][1];
                }

            }
        }
        if(dp[cnt-1][p1]!=1){//如果不唯一，说明方案不唯一
            printf("no\n");
        }
        else{
            vector<int>ans;
            ans.clear();
            int t=p1;
            for(int i=cnt-1;i>=1;i--){
                int tmp=t-pre[i][t];//选前i个大集合t个好人时，第i个1大集合里面好人的个数
                if(tmp==a[i][0]){
                    for(int j=0;j<a[i][0];j++)
                      ans.push_back(b[i][0][j]);
                }
                else{
                    for(int j=0;j<a[i][1];j++)
                      ans.push_back(b[i][1][j]);
                }
                t=pre[i][t];//选前i个大集合t个好人时，第i-1个1大集合里面好人的个数
            }
            sort(ans.begin(),ans.end());//按字典序输出
            for(int i=0;i<ans.size();i++)
              printf("%d\n",ans[i]);
            printf("end\n");
        }
    }
    return 0;
}