POJ 1417 True Liars

POJ连炸多日……

1.发现a,b相同会回答yes 否则回答no

2.套用并查集模板 画图

设边权:相同为0,不同为1

猜\(fav[fa1]=fav[a] \) xor \( fav[b] \;\) xor \( d\),枚举各种情况果然成立……

3.得到一棵树

其实中途会进行路径压缩……

可以统计每棵树中与代表元素相同的个数(A[i])和不同的个数(B[i])(边权为1说明不同,为0说明相同)

然后问题就转换成

\(n = 树的棵数\)

\(X[i] = A[i]\;\;\;or\;\;\;B[i]\;\;\;\left( {1 \le i \le n} \right)\)

\(S[i] = \left\{ {\begin{array}{*{20}{c}}
{X[i]}&{i = 1}\\
{S[i - 1] + X[i]}&{2 \le i \le n}
\end{array}} \right.\)

问是否有且仅有1中选择方法使$S[n]=p1$

刚开始用暴力枚举$O(2^n)$ 一定超时……

犯的错误:

注意统计每棵树的时候有可能会错,如

如果按照没有访问根节点就……

犯的错误

  1 #include<cstdio>
  2 #include<cstring>
  3 #include<algorithm>
  4 #ifndef max
  5 #define max(a,b) ((a)>(b)?(a):(b))
  6 #endif
  7 #define REP(x,i,j) for(int x=i; x<j; x++)
  8 #define REPE(x,i,j) for(int x=i; x<=j; x++)
  9 #define MAXN 607
 10 using namespace std;
 11 int fa[MAXN];
 12 int fav[MAXN];
 13 int n,p,q;
 14 inline void initu() {
 15     REPE(i,0,n) {
 16         fa[i]=i;
 17         fav[i]=0;
 18     }
 19 }
 20
 21 inline int findu(int x) {
 22     int t=x, p;
 23     int v=0,vt;
 24     while(t!=fa[t]) {
 25         v^=fav[t];
 26         t=fa[t];
 27     }
 28     while(x!=t) {
 29         vt =v;
 30         p=fa[x];
 31         fa[x]=t;
 32         v^=fav[x];
 33         fav[x]=vt;
 34         x=p;
 35     }
 36     return t;
 37 }
 38
 39 //inline void uu(int x, int y, int d) {
 40 //    int a=findu(x), b=findu(y);
 41 //    int va=fav[x], vb=fav[y];
 42 //    fa[a]=b;
 43 //    fav[a]=va^vb^d;
 44 //}
 45
 46 int main() {
 47     int a;
 48     while(~scanf("%d%d%d", &a, &p, &q) && (a || p || q)) {
 49         n=p+q;
 50         initu();
 51         REP(i,0,a) {
 52             int x,y;
 53             char s[4];
 54             scanf("%d%d%s", &x, &y, s);
 55             bool d = s[0]==‘n‘;
 56             int a=findu(x), b=findu(y);
 57             if(a!=b) {
 58                 fa[a]=b;
 59                 fav[a]=fav[x]^fav[y]^d;
 60             }
 61         }
 62         if(p==q) {
 63             printf("no\n");
 64         } else {
 65             bool gen[MAXN]; memset(gen,0,sizeof gen);
 66             int cnt[MAXN][2]; memset(cnt,0,sizeof cnt);
 67             int dp[MAXN][MAXN]; memset(dp,0,sizeof dp);
 68             int cntgen[MAXN]; memset(cntgen,0,sizeof cntgen);
 69             dp[0][0]=1;
 70             int ki = 0;
 71             REPE(i,1,n) {
 72                 int t = findu(i);
 73                 if(!gen[t]){ki++;gen[t]=true;cntgen[ki]=t;}
 74                 cnt[ki][fav[i]]++;
 75             }
 76             REPE(i,1,ki){
 77                 for(int j=p;j>=0;j--){
 78                     if(j-cnt[i][0]>=0&&dp[i-1][j-cnt[i][0]]){
 79                         dp[i][j]+=dp[i-1][j-cnt[i][0]];
 80                     }
 81                     if(j-cnt[i][1]>=0&&dp[i-1][j-cnt[i][1]]){
 82                         dp[i][j]+=dp[i-1][j-cnt[i][1]];
 83                     }
 84                 }
 85             }
 86             if(dp[ki][p]!=1) {
 87                 printf("no\n");
 88                 continue;
 89             } else {
 90                 int ansarr[MAXN], ansarri = 0; memset(ansarr,0,sizeof ansarr);
 91                 for(int i=ki;i>=1;i--) {
 92                     if(p-cnt[i][0]>=0&&dp[i-1][p-cnt[i][0]]){
 93                         for(int j=1;j<=n;j++){
 94                             if(fa[j]==cntgen[i]&&fav[j]==0)ansarr[ansarri++]=j;
 95                         }
 96                         p-=cnt[i][0];
 97                     } else {
 98                         for(int j=1;j<=n;j++){
 99                             if(fa[j]==cntgen[i]&&fav[j]==1)ansarr[ansarri++]=j;
100                         }
101                         p-=cnt[i][1];
102                     }
103                 }
104                 sort(ansarr,ansarr+ansarri);
105                 REP(i,0,ansarri) {
106                     printf("%d\n", ansarr[i]);
107                 }
108                 printf("end\n");
109             }
110         }
111     }
112     return 0;
113 }

WA代码

后来抄了个DP,还不知道怎么分析:(

还得多练DP:(

  1 #include<cstdio>
  2 #include<cstring>
  3 #include<algorithm>
  4 #include<map>
  5 #ifndef max
  6 #define max(a,b) ((a)>(b)?(a):(b))
  7 #endif
  8 #define REP(x,i,j) for(int x=i; x<j; x++)
  9 #define REPE(x,i,j) for(int x=i; x<=j; x++)
 10 #define MAXN 1007
 11 using namespace std;
 12 int fa[MAXN];
 13 int fav[MAXN];
 14 int n,p,q;
 15
 16 bool gen[MAXN];
 17 int cnt[MAXN][2];
 18 int dp[MAXN][MAXN];
 19 int cntgen[MAXN];
 20 map<int,int> kitogen;
 21 inline void initu() {
 22     REPE(i,0,n) {
 23         fa[i]=i;
 24         fav[i]=0;
 25     }
 26 }
 27
 28 inline int findu(int x) {
 29     int t=x, p;
 30     int v=0,vt;
 31     while(t!=fa[t]) {
 32         v^=fav[t];
 33         t=fa[t];
 34     }
 35     while(x!=t) {
 36         vt =v;
 37         p=fa[x];
 38         fa[x]=t;
 39         v^=fav[x];
 40         fav[x]=vt;
 41         x=p;
 42     }
 43     return t;
 44 }
 45
 46 //inline void uu(int x, int y, int d) {
 47 //    int a=findu(x), b=findu(y);
 48 //    int va=fav[x], vb=fav[y];
 49 //    fa[a]=b;
 50 //    fav[a]=va^vb^d;
 51 //}
 52
 53 int main() {
 54     int a;
 55     while(~scanf("%d%d%d", &a, &p, &q) && (a || p || q)) {
 56         n=p+q;
 57         initu();
 58         memset(gen,0,sizeof gen);
 59         memset(cnt,0,sizeof cnt);
 60         memset(dp,0,sizeof dp);
 61         memset(cntgen,0,sizeof cntgen);
 62         kitogen.clear();
 63         REP(i,0,a) {
 64             int x,y;
 65             char s[4];
 66             scanf("%d%d%s", &x, &y, s);
 67             bool d = s[0]==‘n‘;
 68             int a=findu(x), b=findu(y);
 69             if(a!=b) {
 70                 fa[a]=b;
 71                 fav[a]=fav[x]^fav[y]^d;
 72             }
 73         }
 74         if(p==q) {
 75             printf("no\n");
 76             continue;
 77         } else {
 78             dp[0][0]=1;
 79             int ki = 0;
 80             REPE(i,1,n) {
 81                 int t = findu(i);
 82                 if(!gen[t]){ki++;gen[t]=true;cntgen[ki]=t;kitogen[t]=ki;}
 83                 cnt[kitogen[t]][fav[i]]++;
 84             }
 85 //            #define DBG(x,...) printf(x, ##__VA_ARGS__)
 86 //            REPE(i,1,ki) {
 87 //                DBG("%d: %d, %d @%d\n", i, cnt[i][0], cnt[i][1], cntgen[i]);
 88 //            }
 89             REPE(i,1,ki){
 90                 for(int j=p;j>=0;j--){
 91                     if(j-cnt[i][0]>=0){
 92                         dp[i][j]+=dp[i-1][j-cnt[i][0]];
 93                     }
 94                     if(j-cnt[i][1]>=0){
 95                         dp[i][j]+=dp[i-1][j-cnt[i][1]];
 96                     }
 97                 }
 98             }
 99             if(dp[ki][p]!=1) {
100                 printf("no\n");
101                 continue;
102             } else {
103                 int ansarr[MAXN], ansarri = 0; memset(ansarr,0,sizeof ansarr);
104                 for(int i=ki;i>=1;i--) {
105                     if(p-cnt[i][0]>=0&&dp[i-1][p-cnt[i][0]]){
106                         for(int j=1;j<=n;j++){
107                             if(fa[j]==cntgen[i]&&fav[j]==0)ansarr[ansarri++]=j;
108                         }
109                         p-=cnt[i][0];
110                     } else if(p-cnt[i][1]>=0&&dp[i-1][p-cnt[i][1]]){
111                         for(int j=1;j<=n;j++){
112                             if(fa[j]==cntgen[i]&&fav[j]==1)ansarr[ansarri++]=j;
113                         }
114                         p-=cnt[i][1];
115                     }
116                 }
117                 sort(ansarr,ansarr+ansarri);
118                 REP(i,0,ansarri) {
119                     printf("%d\n", ansarr[i]);
120                 }
121                 printf("end\n");
122             }
123         }
124     }
125     return 0;
126 }

AC代码

原文地址:https://www.cnblogs.com/sahdsg/p/10356873.html

时间: 2024-09-30 20:53:51

POJ 1417 True Liars的相关文章

POJ 1417 True Liars 并查集+背包

题目链接:http://poj.org/problem?id=1417 解题思路:比较容易想到的是并查集,然后把第三组数据测试一下之后发现这并不是简单的并查集,而是需要合并之后然后判断的.并且鉴于题目要求输出数据,因此还要记录数据,可以说是非常有意思的题目. 首先,如果a b yes,那么a与b一定都是圣人或者恶人:反之,如果a b no,那么两者一个圣人,一个恶人.因此可以将所有元素分为若干个集合,每个集合中放两个小集合,表示两种不一样的人,当然并不知道到底哪个里面是圣人,恶人. 另一个比较棘

POJ 1417 True Liars(并查集+DP)

大意: 一个岛上有神与恶魔两个种族,神会说真话,恶魔会说假话.已知神与恶魔的个数,但不知道具体个人是属于哪个. n,x,y 这个人问n次 ,x为神的个数,y为恶魔的个数. 每次的问题为 xi,yi,a 问xi ,yi是否为神? a为yes/no.注意xi,yi可能为同一个人 若最终可得出哪些是神则从小到大输出神的编号,并最终输出end 否则输出no 思路: 经过简单推理可得,只要是说yes,xi,yi为同一个族,no则不为同一个族. 这样通过使用并查集+relation(relation[i]为

poj 1417

True Liars Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 2221   Accepted: 685 Description After having drifted about in a small boat for a couple of days, Akira Crusoe Maeda was finally cast ashore on a foggy island. Though he was exha

POJ1417:True Liars(DP+带权并查集)

True Liars Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 16338    Accepted Submission(s): 5724 题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3038 Description: After having drifted about in a

POJ1417 True Liars

题意 Language:Default True Liars Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 6392 Accepted: 2080 Description After having drifted about in a small boat for a couple of days, Akira Crusoe Maeda was finally cast ashore on a foggy island. T

poj 1417 并查集+dp

转自:点我 题目:给出p1+p2个人,其中p1个是好人,p2个是坏人.然后有一些关系 ,a说b是好人(坏人).其中没有矛盾的,判断是否有唯一解判断哪些人是好人,哪些人是坏人. 其中比较重要的是,好人总说真话,坏人总说假话.不需要判断矛盾.唯一解 http://poj.org/problem?id=1417 其中好人说真话,坏人说假话这点很重要. 那么如果一个人说另一个人是好人,那么如果这个人是好人,说明 对方确实是好人,如果这个是坏人,说明这句话是假的,对方也是坏人. 如果一个人说另一个人是坏人

F - True Liars 带权并查集

After having drifted about in a small boat for a couple of days, Akira Crusoe Maeda was finally cast ashore on a foggy island. Though he was exhausted and despaired, he was still fortunate to remember a legend of the foggy island, which he had heard

【POJ1417】【带标记并查集+DP】True Liars

Description After having drifted about in a small boat for a couple of days, Akira Crusoe Maeda was finally cast ashore on a foggy island. Though he was exhausted and despaired, he was still fortunate to remember a legend of the foggy island, which h

F - True Liars - poj1417(背包+并查集)

题意:有这么一群人,一群好人,和一群坏人,好人永远会说实话,坏人永远说假话,现在给你一组对话和好人与坏人的数目P1, P2. 数据里面的no是A说B是坏人, yes代表A说B是好人,就是这样,问题能不能从这些话里面得出来唯一的解,就是可以确定谁是好人谁是坏人,如果不能输出no,如果可以输出所有的好人. 分析,可以把这些人依据他们中的关系分成几个小集合,集合里面保存两类人的数目,然后DP求出来好人或者坏人是不是唯一的即可,‘ 注意并查集时候可以这么认为凡是yes都是同类,no都是异类 //////