True Liars POJ - 1417

最新推荐文章于 2020-05-03 16:42:06 发布

klchen0112

最新推荐文章于 2020-05-03 16:42:06 发布

阅读量325

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Union-Find Set Dynamic Programing knapsack problem

本文链接：https://blog.youkuaiyun.com/weixin_40959045/article/details/88382618

Dynamic Programing 同时被 3 个专栏收录

38 篇文章

订阅专栏

Union-Find Set

13 篇文章

订阅专栏

knapsack problem

13 篇文章

订阅专栏

本文探讨了权值并查集在解决特定问题中的应用，通过一个实例详细阐述了如何结合背包问题进行算法设计。从初始化并查集到实现逆向输出唯一解的过程，文章深入浅出地讲解了算法原理与实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

权值并查集

之后就是一个简单的背包

之后逆向输出，显然若当前唯一则前置也必定唯一

 #include<cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <cstdlib>
 #include <vector>
 using namespace std;
 #define fst first
 #define sec second
 #define sci(num) scanf("%d",&num)
 #define scl(num) scanf("%lld",&num)
 #define mem(a,b) memset(a,b,sizeof a)
 #define cpy(a,b) memcopy(a,b,sizeof b)
 typedef long long LL;
 typedef pair<int,int> P;
 const int MAX_N = 1010;
 const int MAX_M = 10000;
 char str[100];
 int Fa[MAX_N],R[MAX_N];
 int N,M,p1,p2;
 vector<int> ss[2][MAX_N];
 int DP[MAX_N][MAX_N];
 int vis[MAX_N];
 void init() {
     mem(DP,0);
     mem(vis,0);
     for (int i = 0;i <= N;i++) {
         Fa[i] = i;
         R[i] = 0;
         ss[0][i].clear();
         ss[1][i].clear();
     }
     DP[0][0] = 1;
 }
 int Find(int x) {
     if (Fa[x] != x) {
         int p = Fa[x];
         Fa[x] = Find(Fa[x]);
         R[x] = R[x] ^ R[p];
     }
     return Fa[x];
 }
 
 int main() {
     while (~scanf("%d%d%d",&M,&p1,&p2)) {
         N = p1 + p2;
         if (N == 0) break;
 
         init();
         for (int i = 0;i < M;i++) {
             int u,v;
             scanf("%d%d%s",&u,&v,&str);
             int k = str[0] == 'n';
             int uf = Find(u);
             int vf = Find(v);
             if (uf != vf) {
                 Fa[uf] = vf;
                 R[uf] = R[u] ^ R[v] ^ k;
             }
         }
         for (int i = 1;i <= N;i++) {
             Find(i);
             ss[R[i]][Fa[i]].push_back(i);
         }
 
         for (int i = 1;i <= N;i++) {
             int d1 = ss[0][i].size();
             int d2 = ss[1][i].size();
             for (int j = 0;j <= p1;j++) {
                 if (d1 == d2 && d1 == 0) {
                     DP[i][j] = DP[i - 1][j];
                     continue;
                 }
                 if (j -d1 >= 0) {
                     DP[i][j] += DP[i - 1][j -d1];
                 }
                 if (j -d2 >= 0) {
                     DP[i][j] += DP[i - 1][j -d2];
                 }
             }
         }
         if (DP[N][p1] != 1) {
             printf("no\n");
         } else {
             vector<int> ans;
             ans.clear();
             for (int i = N;i >= 1;i--) {
                 int d1 = ss[0][i].size();
                 int d2 = ss[1][i].size();
                 if (d1 + d2 == 0) continue;
                 if (p1 - d1 >= 0 && p2 - d2 >= 0 && DP[i- 1][p1 - d1] == 1) {
                     for (int k = 0;k < ss[0][i].size();k++) {
                         ans.push_back(ss[0][i][k]);
                     }
                     p1 -= d1;
                     p2 -= d2;
                 } else {
                     for (int k = 0;k < ss[1][i].size();k++) {
                         ans.push_back(ss[1][i][k]);
                     }
                     p1 -= d2;
                     p2 -= d1;
                 }
             }
             sort(ans.begin(),ans.end());
             for (int i = 0;i < ans.size();i++) {
                 printf("%d\n",ans[i]);
             }
             printf("end\n");
          }
     }
     return 0;
 }