题面

题意: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

hihoCoder-1830 2018亚洲区预选赛北京赛站网络赛 C.Cheat 模拟相关推荐

  1. ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 【bfs + 记忆化搜索 + 剪枝】 AC 代码

    ACM 北京区域赛 bfs+剪枝+ms 第一个一遍过的题目,基本没有看题解 记忆搜索当中,注意初始化成一个特殊值:而在访问之后,每个点就会有一个不同于INF(或者 -1等特殊标记)的值 先到先得,适者 ...

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

    题面 题意:N*M的网格图里,有起点S,终点T,然后有'.'表示一般房间,'#'表示毒气房间,进入毒气房间要消耗一个氧气瓶,而且要多停留一分钟,'B'表示放氧气瓶的房间,每次进入可以获得一个氧气瓶,最 ...

  3. hihoCoder-1829 2018亚洲区预选赛北京赛站网络赛 B.Tomb Raider 暴力 字符串

    题面 题意:给你n个串,每个串都可以选择它的一个长度为n的环形子串(比如abcdf的就有abcdf,bcdfa,cdfab,dfabc,fabcd),求这个n个串的这些子串的最长公共子序列(每个串按顺 ...

  4. ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 Tomb Raider(map+二进制枚举)

    #1829 : Tomb Raider 时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述 Lara Croft, the fiercely independent daugh ...

  5. ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 80 Days(双向队列+尺取法)

    #1831 : 80 Days 时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述 80 Days is an interesting game based on Jules ...

  6. ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 D【队列】

    #1831 : 80 Days 时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述 80 Days is an interesting game based on Jules ...

  7. ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 D. 80 Days

    题解 题目大意 n个点组成一个环形 初始钱为m 从i走到j需要-b[i] + a[j] 要求按照顺时针走完所有的点(不用再回到起点) 过程中m不能小于0 输出最小的起点编号 直接把a[i]和b[i]合 ...

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

    Saving Tang Monk II Tomb Raider Cheat 80 Days Odd Chess Shortest Path Problem The Mole K-Dimensional ...

  9. ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 A Saving Tang Monk II【分层bfs】

    时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述 <Journey to the West>(also <Monkey>) is one of the ...

最新文章

  1. catkin_make后输出:No module named ‘catkin_pkg‘
  2. html css 极简模板,极简主义作品展示HTML模板
  3. 图解:从单个服务器扩展到百万用户的系统
  4. 结队-五子棋游戏-项目进度
  5. windows命令行无法启动redis_Win10 3分钟简单、快速安装Redis
  6. 爬虫多线程生产者与消费者
  7. QT c++ 中使用PostMessage/SendMessage实例
  8. Java中的函数传递
  9. json解析对应的value为null_徒手撸一个JSON解析器
  10. 两高发布司法解释 依法严惩涉地下钱庄犯罪
  11. [水池] 灌水专用:搜狗输入法里收集的纯文字表情
  12. 神经网络 异或_深度学习入门笔记(2)线性神经网络
  13. angular学习-入门基础
  14. 牛顿插值算法MATLAB实现
  15. 【转载】扫描渗透等工具介绍
  16. 安装ubuntu系统,保留原始分区数据
  17. MediaRecorder录制音频文件
  18. Windows 8 六大关机模式 详解
  19. Ubuntu调整缩放
  20. 读书笔记:100岁前的健康指南

热门文章

  1. Gartner发布对2022年及以后IT组织和用户的十大预测
  2. 离奇的梦境,能够防范大脑过拟合
  3. 张亚勤、韦乐平等综述论文:通信人工智能的下一个十年
  4. “万物就只是5万亿个参数”,AI模型GPT-3让人怀疑人生
  5. 未来网络经济的99个趋势报告
  6. Nature Human Behavior:大脑对不公平的反应有助预测抑郁症
  7. 不允许程序员透露薪资!!!凭啥?
  8. 知乎高赞:我的编程能力从什么时候开始突飞猛进的?
  9. 大厂面试录取通过率不到3%,我真是太太太难了......
  10. Apple导出p12证书 导出证书为p12 Apple开发