poj 1417 True Liars（并查集+背包dp）

题目链接：http://poj.org/problem?id=1417

题意：就是给出n个问题有p1个好人，p2个坏人，问x，y是否是同类人，坏人只会说谎话，好人只会说实话。

最后问能否得出全部的好人编号是多少并且从小到大输出

由于好人只说实话坏人只说谎话。一个人说另一个人不是同类，如果他是好人那么另外一个人就是坏人，如果这是坏人那么另外一个人就是也是坏人

一个人说另一个人是同类，如果他是好人那么另一个人就是好人，如果这时坏人那么另一个人也是好人。

所以这种关系正好方便枚举，因为要么这群人是好人要么就是坏人，一旦关系定了只要确定是好人还是坏人就行了。

但是这题用枚举不行。怎么确定不了所有好人的个数，那是当满足条件的情况没有或者大于1个如果用枚举那就太复杂了。

于是可以想到用背包来解决这类问题。背包dp[i][j]来存储前i个关系中得到好人个数为j的有多少个。

为什么会想到用背包来解决这个问题呐？因为01背包就是枚举总结的一种优化，01背包可以保存达到方案的最大权值或者最大个数

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
const int M = 1010;
int n , p1 , p2 , f[M] , root[M];
void init() {
    for(int i = 1 ; i <= p1 + p2 ; i++) {
        f[i] = i , root[i] = 0;
    }
}
int find(int x) {
    if(x == f[x])
        return x;
    int tmp = find(f[x]);
    root[x] = (root[x] + root[f[x]]) % 2;
    return f[x] = tmp;
}
bool vis[M];
vector<int>vc[M][3];
int dp[M][M] , v[M][3] , pre[M][M];
int main() {
    int x , y;
    char cp[10];
    while(scanf("%d%d%d" , &n , &p1 , &p2)) {
        init();
        int tmp;
        if(n == 0 && p1 == 0 && p2 == 0)
            break;
        for(int i = 0 ; i < n ; i++) {
            scanf("%d%d%s" , &x , &y , cp);
            int a = find(x) , b = find(y);
            if(cp[0] == 'y')
                tmp = 0;
            else
                tmp = 1;
            if(a != b) {
                f[a] = b;
                root[a] = (root[y] - root[x] + tmp + 2) % 2;
            }
        }
        int cnt = 1;
        for(int i = 0 ; i < M ; i++) {
            vc[i][0].clear();
            vc[i][1].clear();
            v[i][0] = 0;
            v[i][1] = 0;
        }
        memset(vis , false , sizeof(vis));
        for(int i = 1 ; i <= p1 + p2 ; i++) {
            if(!vis[i]) {
                int ro = find(i);
                for(int j = i ; j <= p1 + p2 ; j++) {
                    int ro2 = find(j);
                    if(ro == ro2) {
                        vis[j] = true;
                        vc[cnt][root[j]].push_back(j);
                        v[cnt][root[j]]++;
                    }
                }
                cnt++;
            }
        }
        for(int i = 0 ; i < cnt ; i++) {
            for(int j = 0 ; j <= p1 ; j++) {
                dp[i][j] = 0;
            }
        }
        dp[0][0] = 1;
        for(int i = 1 ; i < cnt ; i++) {
            for(int j = p1 ; j >= 0 ; j--) {
                if(j >= v[i][0] && dp[i - 1][j - v[i][0]]) {
                    dp[i][j] += dp[i - 1][j - v[i][0]];
                    pre[i][j] = j - v[i][0];
                }
                if(j >= v[i][1] && dp[i - 1][j - v[i][1]]) {
                    dp[i][j] += dp[i - 1][j - v[i][1]];
                    pre[i][j] = j - v[i][1];
                }
            }
        }
        if(dp[cnt - 1][p1] != 1) {
            printf("no\n");
            continue;
        }
        else {
            vector<int>ans;
            ans.clear();
            int gg = p1;
            int temp;
            for(int i = cnt - 1 ; i >= 1 ; i--) {
                temp = gg - pre[i][gg];
                gg = pre[i][gg];
                if(v[i][0] == temp) {
                    int len = vc[i][0].size();
                    for(int j = 0 ; j < len ; j++) {
                        ans.push_back(vc[i][0][j]);
                    }
                }
                else {
                    int len = vc[i][1].size();
                    for(int j = 0 ; j < len ; j++) {
                        ans.push_back(vc[i][1][j]);
                    }
                }
            }
            sort(ans.begin() , ans.end());
            int len = ans.size();
            for(int i = 0 ; i < len ; i++) {
                printf("%d\n" , ans[i]);
            }
            printf("end\n");
        }
    }
    return 0;
}