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

Posted 2021-01-07 qywhy

题面

题意: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("
");
402                     else printf(" ");
403                 }
404             }
405         }
406     }
407     return 0;
408 }