2018亚洲区预选赛北京赛站网络赛 C.Cheat

题面

题意:4个人围一圈坐着,每个人13张牌,然后从第一个人开始,必须按照A-K的顺序出牌,一个人出牌后,剩下的人依次可以选择是否质疑他,例如,第一个人现在必须出8(因为按照A-K顺序轮到了),可是他没有或者有,无论如何他会说,我出了x个8,这x张牌就背面朝上的放在桌上,如果有人质疑,才会翻开,然后如果发现这并不是x个8,第一个人就要把桌子上所有的牌收回手上,如果是x个8,这个人就要自己把所有牌收回去,最先出完牌的人,且没有被质疑成功的,就是赢家,输出最后4个人手上的剩下牌。然后给出了4个人的牌型,和策略。

题解:模拟,耐心模拟。坑在于中间要求字典序最小,10<2<3<...<9<A<J<K<Q 而不是A<J<Q<K(调了3h才发现。)

  1 #include<bits/stdc++.h>
  2 using namespace std;
  3 const int INF=0x3f3f3f3f;
  4 struct Node
  5 {
  6     int cnt[15];
  7     void clear()
  8     {
  9         for (int i=1;i<=13;i++)  cnt[i]=0;
 10     }
 11     bool empty()
 12     {
 13         for (int i=1;i<=13;i++)
 14             if(cnt[i]) return 0;
 15         return 1;
 16     }
 17     int get()
 18     {
 19         if(cnt[10]) return 10;
 20         for (int i=2;i<=9;i++) if(cnt[i]) return i;
 21         if (cnt[1]) return 1;
 22         if (cnt[11]) return 11;
 23         if (cnt[13]) return 13;
 24         if (cnt[12]) return 12;
 25         return 0;
 26     }
 27     int fuckget()
 28     {
 29         int num=INF,index;
 30         if (cnt[10]<num&&cnt[10]>=1)
 31         {
 32             num=cnt[10];
 33             index=10;
 34         }
 35         for (int i=2;i<=9;i++)
 36             if(cnt[i]<num&&cnt[i]>=1)
 37             {
 38                 num=cnt[i];
 39                 index=i;
 40             }
 41         if (cnt[1]<num&&cnt[1]>=1)
 42         {
 43             num=cnt[1];
 44             index=1;
 45         }
 46         if (cnt[11]<num&&cnt[11]>=1)
 47         {
 48             num=cnt[11];
 49             index=11;
 50         }
 51         if (cnt[13]<num&&cnt[13]>=1)
 52         {
 53             num=cnt[13];
 54             index=13;
 55         }
 56         if(cnt[12]<num&&cnt[12]>=1)
 57         {
 58             num=cnt[12];
 59             index=12;
 60         }
 61         return index;
 62     }
 63     int del(int i) {cnt[i]--;}
 64     int add(int i) {cnt[i]++;}
 65 }node[4],discard;
 66 char s[3];
 67 void insert(int index)
 68 {
 69     int len=strlen(s);
 70     if(s[0]==‘1‘&&s[1]==‘0‘)
 71     {
 72         node[index].cnt[10]++;
 73         return;
 74     }
 75     char ch=s[0];
 76     if(ch==‘A‘) node[index].cnt[1]++;
 77     else if(ch==‘J‘) node[index].cnt[11]++;
 78     else if(ch==‘Q‘) node[index].cnt[12]++;
 79     else if(ch==‘K‘) node[index].cnt[13]++;
 80     else node[index].cnt[ch-‘0‘]++;
 81 }
 82 int calc(int x)
 83 {
 84     x=x+1;
 85     if(x==14) x=1;
 86     return x;
 87 }
 88 void jianpai(int index)
 89 {
 90     for (int i=1;i<=13;i++) node[index].cnt[i]+=discard.cnt[i];
 91     discard.clear();
 92 }
 93 void out(int x) {
 94     if(x==1) printf("A");
 95     else if(x>=2&&x<=10) printf("%d",x);else
 96     if(x==11) printf("J");else
 97     if(x==12) printf("Q");else
 98     if(x==13) printf("K");
 99 }
100 vector<int> vec;
101 int main()
102 {
103     while(~scanf("%s",s))
104     {
105         for (int i=0;i<=3;i++)node[i].clear();
106         discard.clear();
107         insert(0);
108         for (int i=1;i<=12;i++)
109         {
110             scanf("%s",s);
111             insert(0);
112         }
113         for (int i=1;i<=3;i++)
114            for (int j=1;j<=13;j++)
115            {
116                 scanf("%s",s);
117                 insert(i);
118             }
119         int index=0,need=1;
120         while(1)
121         {
122             bool ok=false;
123             for (int i=0;i<=3;i++)
124             {
125                 if(node[i].empty())
126                 {
127                     ok=true;
128                     break;
129                 }
130             }
131             if(ok) break;
132             if(index==0)
133             {
134                 if(node[index].cnt[need])
135                  {
136                     node[index].del(need);
137                     discard.add(need);
138                     for (int i=1;i<=3;i++)
139                     {
140                         int p=(index+i)%4;
141                         if(p==1)
142                         {
143                             if(node[p].cnt[calc(need)]==0)
144                              {
145                                 jianpai(p);
146                                 break;
147                             }
148                         }else
149                         if(p==3)
150                         {
151                             if(node[index].empty())
152                             {
153                                 jianpai(p);
154                                 break;
155                             }
156                         }
157                     }
158                 }else
159                 {
160                     int fuck=node[index].get();
161                     node[index].del(fuck);
162                     discard.add(fuck);
163                     for (int i=1;i<=3;i++)
164                     {
165                         int p=(index+i)%4;
166                         if(p==1)
167                         {
168                             if(node[p].cnt[calc(need)]==0)
169                             {
170                                 jianpai(index);
171                                 break;
172                             }
173                         }else
174                         if(p==2) {
175                             if(node[p].cnt[need]==4) {
176                                 jianpai(index);
177                                 break;
178                             }
179                         }else
180                             if(node[index].empty()) {
181                                 jianpai(index);
182                                 break;
183                             }
184                     }
185                 }
186             }else
187             if(index==1)
188             {
189                 if(node[index].cnt[need])
190                 {
191                     while(node[index].cnt[need])
192                     {
193                         node[index].del(need);
194                         discard.add(need);
195                     }
196                     for (int i=1;i<=3;i++)
197                     {
198                         int p=(index+i)%4;
199                         if(p==2)
200                         {
201                             if(node[p].cnt[need]==4)
202                             {
203                                 jianpai(p);
204                                 break;
205                             }
206                         }else if(p==3)
207                         {
208                             if(node[index].empty())
209                             {
210                                 jianpai(p);
211                                 break;
212                             }
213                         }
214                     }
215                 }else
216                 {
217                     int fuck=node[index].get();
218                     node[index].del(fuck);
219                     discard.add(fuck);
220                     for (int i=1;i<=3;i++)
221                     {
222                         int p=(index+i)%4;
223                         if(p==2)
224                         {
225                             if(node[p].cnt[need]==4)
226                             {
227                                 jianpai(index);
228                                 break;
229                             }
230                         }else if(p==3)
231                         {
232                             if(node[index].empty())
233                             {
234                                 jianpai(index);
235                                 break;
236                             }
237                         }else
238                         {
239                             if(1+node[p].cnt[need]>4)
240                             {
241                                 jianpai(index);
242                                 break;
243                             }
244                         }
245                     }
246                 }
247             }else
248             if(index==2)
249             {
250                 if(node[index].cnt[need])
251                 {
252                     while(node[index].cnt[need])
253                     {
254                         node[index].del(need);
255                         discard.add(need);
256                     }
257                     for (int i=1;i<=3;i++)
258                     {
259                         int p=(index+i)%4;
260                         if(p==3)
261                         {
262                             if(node[index].empty())
263                             {
264                                 jianpai(p);
265                                 break;
266                             }
267                         }
268                     }
269                 }else
270                 {
271                     int num=0;
272                     int fuck=node[index].fuckget();
273                     while(node[index].cnt[fuck])
274                     {
275                         node[index].del(fuck);
276                         discard.add(fuck);
277                         num++;
278                     }
279                     for (int i=1;i<=3;i++)
280                     {
281                         int p=(index+i)%4;
282                         if(p==3)
283                         {
284                             if(node[index].empty())
285                             {
286                                 jianpai(index);
287                                 break;
288                             }
289                         }else if(p==0)
290                         {
291                             if(num+node[p].cnt[need]>4)
292                             {
293                                 jianpai(index);
294                                 break;
295                             }
296                         }
297                     }
298                 }
299             }else
300             {
301                 if(node[index].cnt[need]>=3)
302                 {
303                     while(node[index].cnt[need])
304                     {
305                         node[index].del(need);
306                         discard.add(need);
307                     }
308                     for (int i=1;i<=3;i++)
309                     {
310                         int p=(index+i)%4;
311                         if(p==0)
312                         {
313                             if(node[p].cnt[calc(need)]==0)
314                             {
315                                 jianpai(p);
316                                 break;
317                             }
318                         }
319                     }
320                 }else
321                 if(node[index].cnt[need]>=1)
322                 {
323                     int num=0;
324                     while(node[index].cnt[need])
325                     {
326                         node[index].del(need);
327                         discard.add(need);
328                         num++;
329                     }
330                     int fuck=node[index].get();
331                     if(fuck)
332                     {
333                         num++;
334                         node[index].del(fuck);
335                         discard.add(fuck);
336                     }
337                     for (int i=1;i<=3;i++)
338                     {
339                         int p=(index+i)%4;
340                         if(p==0)
341                         {
342                             if(node[p].cnt[calc(need)]==0)
343                             {
344                                 if(fuck) jianpai(index);
345                                 else jianpai(p);
346                                 break;
347                             }
348                             if(num+node[p].cnt[need]>4)
349                             {
350                                 jianpai(index);
351                                 break;
352                             }
353                         }
354                     }
355                 }else
356                 {
357                     int fuck=node[index].get();
358                     node[index].del(fuck);
359                     discard.add(fuck);
360                        for (int i=1;i<=3;i++)
361                     {
362                         int p=(index+i)%4;
363                         if(p==0)
364                         {
365                             if(node[p].cnt[calc(need)]==0)
366                             {
367                                 jianpai(index);
368                                 break;
369                             }
370                             if(node[p].cnt[need]+1>4)
371                             {
372                                 jianpai(index);
373                                 break;
374                             }
375                         }else
376                         if(p==2)
377                         {
378                             if(node[p].cnt[need]==4)
379                             {
380                                 jianpai(index);
381                                 break;
382                             }
383                         }
384                     }
385                 }
386             }
387             need=calc(need);
388             index=(index+1)%4;
389         }
390         for (int i=0;i<=3;i++)
391         {
392             if(node[i].empty()) puts("WINNER");else
393             {
394                 vec.clear();
395                 for (int j=1;j<=13;j++)
396                     for (int k=1;k<=node[i].cnt[j];k++) vec.push_back(j);
397                 int len=(int)vec.size();
398                 for (int i=0;i<=len-1;i++)
399                 {
400                     out(vec[i]);
401                     if(i==len-1) printf("\n");
402                     else printf(" ");
403                 }
404             }
405         }
406     }
407     return 0;
408 }

原文地址:https://www.cnblogs.com/qywhy/p/9691502.html

时间: 2024-08-30 14:46:06

2018亚洲区预选赛北京赛站网络赛 C.Cheat的相关文章

ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 A.Saving Tang Monk II(优先队列广搜)

#include<bits/stdc++.h> using namespace std; const int maxN = 123; const int inf = 1e9 + 7; char G[maxN][maxN]; int times[maxN][maxN][6]; int n, m, sx, sy, ex, ey, ans; int dir[4][2] = {{0,1},{1,0},{0,-1},{-1,0}}; struct node { int x, y, t, o; bool

2018亚洲区预选赛北京赛站网络赛 A.Saving Tang Monk II BFS

题面 题意:N*M的网格图里,有起点S,终点T,然后有'.'表示一般房间,'#'表示毒气房间,进入毒气房间要消耗一个氧气瓶,而且要多停留一分钟,'B'表示放氧气瓶的房间,每次进入可以获得一个氧气瓶,最多只能带5个,'P'表示有加速器的房间,进入可以获得一个,可以拥有无限个,然后使用一个可以让你用的时间减一. 题解:对于P房间,也就是到达时不花费时间, 对于#房间,也就是进入前必须要有氧气瓶,消耗的时间为2 对于B房间,氧气瓶数量num=min(num+1,5) 因为有氧气瓶,所以每一个节点状态除

ACM/ICPC 2018亚洲区预选赛北京赛站网络赛

题意:到一个城市得钱,离开要花钱.开始时有现金.城市是环形的,问从哪个开始,能在途中任意时刻金钱>=0; 一个开始指针i,一个结尾指针j.指示一个区间.如果符合条件++j,并将收益加入sum中(收益可能是负数).不符合就++i,并从sum中退掉收益直到sum>=0;区间长度为n时i的位置就是结果. 正确性证明:假设[a,b]是第一个合法区间.某时刻i,j都<a,i在a左边,因此j不可能扩到b右边(否则[a,b]不是第一个合法区间).只可能j仍落在a左边,或者落到a,b中间.在i<a

Saving Tang Monk II HihoCoder - 1828 2018北京赛站网络赛A题

<Journey to the West>(also <Monkey>) is one of the Four Great Classical Novels of Chinese literature. It was written by Wu Cheng'en during the Ming Dynasty. In this novel, Monkey King Sun Wukong, pig Zhu Bajie and Sha Wujing, escorted Tang Mon

2017ICPC北京赛区网络赛 Visiting Peking University(简单思维)

描述 Ming is going to travel for n days and the date of these days can be represented by n integers: 0, 1, 2, …, n-1. He plans to spend m consecutive days(2 ≤ m ≤ n)in Beijing. During these m days, he intends to use the first day and another day to vis

hdu 4041 2011北京赛区网络赛F 组合数+斯特林数 ***

插板法基础知识 斯特林数见百科 1 #include<iostream> 2 #include<cmath> 3 #include<cstdio> 4 #include<cstring> 5 #define LL long long 6 #define eps 1e-7 7 #define MOD 1000000007 8 using namespace std; 9 int c[2001][2001]={1},stir2[1005][1005]={1};

2015 ACM-ICPC国际大学生程序设计竞赛北京赛区网络赛 1002 Mission Impossible 6

题目链接: #1228 : Mission Impossible 6 解题思路: 认真读题,细心模拟,注意细节,就没有什么咯!写这个题解就是想记录一下rope的用法,以后忘记方便复习. rope(块状链表)属于SGI STL的一部分,不属于ISO C++标准库,但libstdc++-v3也包含了扩展,在头文件#include<ext/rope>,using namespace __gnu_cxx命名空间中.可以在很短的时间内实现快速的插入.删除和查找字符串. rope.size()    返回

2015 ACM-ICPC 北京赛区 网络赛 部分 题解

由于博主水平及智商不足,所以暂时只能放出下列的题目的题解. A B D F G H 需要其他题解请自行前往 http://talk.icpc-camp.org/ 题目地址:hihocoder 1227-1236 A.  The Cats' Feeding Spots 题意:给出M个点,求以其中一个点为圆心,最小半径的圆,使得这个圆里恰好有N个点. (半径一定要是整数,且点不能恰好在圆上). 方法:暴力,稍微注意一下精度什么的就好了,1A. 1 #include <bits/stdc++.h>

hdu 4050 2011北京赛区网络赛K 概率dp ***

题目:给出1-n连续的方格,从0开始,每一个格子有4个状态,左右脚交替,向右跳,而且每一步的步长必须在给定的区间之内.当跳出n个格子或者没有格子可以跳的时候就结束了,求出游戏的期望步数 0:表示不能到达这个格子 1:表示左脚跳进这个格子 2:表示右脚跳进这个格子 3:随意哪个脚跳进这个格子,而且下一步随意用哪个脚 dp[i][j] :表示走到第 i 个格子在 j 状态的期望. 当j=1时,你可以走到dp[i+k][2],dp[i+k][3], 当j=2时,你可以走到dp[i+k][1],dp[i