2014多校第六场 1010 || HDU 4930 Fighting the Landlords (模拟)

题目链接

题意 : 玩斗地主,出一把,只要你这一把对方要不了或者你出这一把之后手里没牌了就算你赢。

思路 : 一开始看了第一段以为要出很多次,实际上只问了第一次你能不能赢或者能不能把牌出尽。

  1 #include <cstdio>
  2 #include <cstring>
  3 #include <iostream>
  4
  5 using namespace std ;
  6
  7 char str1[20],str2[20] ;
  8 int hash1[20],hash2[20] ;
  9
 10 int judge(char ch)
 11 {
 12     if(ch == ‘T‘)
 13         return 10 ;
 14     else if(ch == ‘J‘)
 15         return 11 ;
 16     else if(ch == ‘Q‘)
 17         return 12 ;
 18     else if(ch == ‘K‘)
 19         return 13 ;
 20     else if(ch == ‘A‘)
 21         return 14 ;
 22     else if(ch == ‘2‘)
 23         return 15 ;
 24     else if(ch == ‘X‘)
 25         return 16 ;
 26     else if(ch == ‘Y‘)
 27         return 17 ;
 28     else return ch-‘0‘ ;
 29 }
 30 int one()
 31 {
 32     int j = 0,x[25] ;
 33     for(int i = 3 ; i < 18 ; i++)
 34         if(hash1[i])
 35         {
 36             x[j++] = hash1[i] ;
 37         }
 38     if(j == 1)
 39         return 1 ;
 40     else if(j == 2)
 41     {
 42         if(hash1[16] && hash1[17]) return 1 ;
 43         if(x[0] == 3 && x[1] <= 2) return 1 ;
 44         if(x[0] <= 2 && x[1] == 3) return 1 ;
 45         if(x[0] == 4 && x[1] == 2) return 1 ;
 46         if(x[0] == 2 && x[1] == 4) return 1 ;
 47     }
 48     else if(j == 3)
 49     {
 50         if(x[1] == 1 && x[0] == 1 && x[2] == 4) return 1 ;
 51         if(x[1] == 1 && x[0] == 4 && x[2] == 1) return 1 ;
 52         if(x[1] == 4 && x[0] == 1 && x[2] == 1) return 1 ;
 53     }
 54     return 0 ;
 55 }
 56 int main()
 57 {
 58     int T ;
 59     cin >> T ;
 60     while(T--)
 61     {
 62         memset(hash1,0,sizeof(hash1)) ;
 63         memset(hash2,0,sizeof(hash2)) ;
 64         scanf("%s %s",str1,str2) ;
 65         int len1 = strlen(str1) ;
 66         int len2 = strlen(str2) ;
 67         for(int i = 0 ; i < len1 ; i++)
 68         {
 69             hash1[judge(str1[i])] ++ ;
 70         }
 71         for(int i = 0 ; i < len2 ; i++)
 72         {
 73             hash2[judge(str2[i])] ++ ;
 74         }
 75         ///如果有王炸
 76         if(hash1[16] && hash1[17])
 77         {
 78             puts("Yes") ;
 79             continue ;
 80         }
 81         ///如果手里的牌一次性能出完
 82         if(one())
 83         {
 84             puts("Yes") ;
 85             continue ;
 86         }
 87         ///如果手里牌无法一次性出完可是对方还有王炸,一定输
 88         if(hash2[16] && hash2[17])
 89         {
 90             puts("No") ;
 91             continue ;
 92         }
 93         ///如果自己有普通的炸,只要比对方大就一定赢,反之如果对方有炸自己一定输
 94         int flag = 0 ;
 95         for(int i = 17 ; i >= 3 ; i--)
 96         {
 97             if(hash1[i] == 4)
 98             {
 99                 flag = 1 ;
100                 break ;
101             }
102             if(hash2[i] == 4)
103             {
104                 flag = -1 ;
105                 break ;
106             }
107         }
108         if(flag == 1)
109         {
110             puts("Yes") ;
111             continue ;
112         }
113         else if(flag == -1)
114         {
115             puts("No") ;
116             continue ;
117         }
118         ///出三张一样,可不带,可带一张,可带两张
119         flag = 0 ;
120         int flag1 = 0 ,flag2 = 0;
121         for(int i = 17 ; i >= 3 ; i--)
122         {
123             if(hash1[i] == 3)
124             {
125                 flag1 = 1 ;
126             }
127             if(hash2[i] == 3)
128             {
129                 flag2 = 1 ;
130             }
131             if(flag1 && !flag2)
132             {
133                 flag = 1 ;
134                 break ;
135             }
136         }
137         if(flag)//不带
138         {
139             puts("Yes") ;
140             continue ;
141         }
142         int a1 = 0,b1 = 0 , a2 = 0,b2 = 0 ;
143         if(flag1 && flag2)
144         {
145             for(int i = 17 ; i >= 3 ; i--)
146             {
147                 if(hash1[i])
148                 {
149                     a1 = 1 ;
150                     if(hash1[i] > 1)
151                         b1 = 1 ;
152                 }
153                 if(hash2[i])
154                 {
155                     a2 = 1 ;
156                     if(hash2[i] > 1)
157                         b2 = 1;
158                 }
159             }
160         }
161         if(a1 && !a2)//带一张
162         {
163             puts("Yes");
164             continue ;
165         }
166         if(b1 && !b2)//带两张
167         {
168             puts("Yes") ;
169             continue ;
170         }
171         ///出一张
172         flag = 0 ;
173         for(int i = 17 ; i >= 0 ; i--)
174         {
175             if(hash1[i])
176             {
177                 flag = 1 ;
178                 break ;
179             }
180             if(hash2[i]) break ;
181         }
182         if(flag)
183         {
184             puts("Yes") ;
185             continue ;
186         }
187         ///出一对
188         flag = 0 ;
189         for(int i = 17 ; i >= 0 ; i--)
190         {
191             if(hash1[i] >= 2)
192             {
193                 flag = 1 ;
194                 break ;
195             }
196             if(hash2[i] >= 2)
197                 break ;
198         }
199         if(flag)
200         {
201             puts("Yes") ;
202             continue ;
203         }
204         ///没有任何情况可以赢了
205         puts("No") ;
206     }
207     return 0 ;
208 }

2014多校第六场 1010 || HDU 4930 Fighting the Landlords (模拟)

时间: 2024-10-16 20:50:34

2014多校第六场 1010 || HDU 4930 Fighting the Landlords (模拟)的相关文章

2014多校第六场 1005 || HDU 4925 Apple Tree

题目链接 题意 : 给你一块n×m的矩阵,每一个格子可以施肥或者是种苹果,种一颗苹果可以得到一个苹果,但是如果你在一个格子上施了肥,那么所有与该格子相邻(指上下左右)的有苹果树的地方最后得到的苹果是两倍,如果(i,j)有一颗苹果树,(i-1,j)与(i,j+1)施了肥,那么苹果应该是1的两倍2,2的两倍4,最后是4个苹果,问你怎么安排苹果和施肥的格子使最后得到的苹果最多. 思路 : 画了图就可以看出来,苹果和苹果,肥与肥之间不要相邻就好了,所有的苹果之间都有施肥,所有施肥的格子都被苹果隔开了才能

2014多校第五场1010 || HDU 4920 Matrix multiplication(矩阵乘法优化)

题目链接 题意 : 给你两个n*n的矩阵,然后两个相乘得出结果是多少. 思路 :一开始因为知道会超时所以没敢用最普通的方法做,所以一直在想要怎么处理,没想到鹏哥告诉我们后台数据是随机跑的,所以极端数据是不可能会有的,而我们一开始一直在想极端数据能接受的方法......后来看了鹏哥的做法,就是把是0的地方都跳过就可以了,用矩阵保存前一个非0数的位置是多少.二师兄给我看了一个代码,人家根本没用别的优化,直接将最里层k的循环提到了最外层,然后就AC了,对此我表示无语. 1 #include <cstd

HDU 4930 Fighting the Landlords 模拟

_(:зゝ∠)_ 4带2居然不是炸弹,, #include <algorithm> #include <cctype> #include <cassert> #include <cstdio> #include <cstring> #include <climits> #include <vector> #include<iostream> using namespace std; #define N 18 #

【HDU】4923 Room and Moor(2014多校第六场1003)

Room and Moor Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)Total Submission(s): 263    Accepted Submission(s): 73 Problem Description PM Room defines a sequence A = {A1, A2,..., AN}, each of which is either 0

2014多校第六场 || HDU 4927 Series 1(杨辉三角组合数)

题目链接 题意 : n个数,每操作一次就变成n-1个数,最后变成一个数,输出这个数,操作是指后一个数减前一个数得到的数写下来. 思路 : 找出几个数,算得时候先不要算出来,用式子代替,例如: 1 2 3 4 5 6 (2-1) (3-2) (4-3) (5-4)(6-5) (3-2-2+1)(4-3-3+2)(5-4-4+3)(6-5-5+4) (4-3-3+2-3+2+2-1)(5-4-4+3-4+3+3-2)(6-5-5+4-5+4+4-3) (5-4-4+3-4+3+3-2-4+3+3-2

2014多校第十场1004 || HDU 4974 A simple water problem

题目链接 题意 : n支队伍,每场两个队伍表演,有可能两个队伍都得一分,也可能其中一个队伍一分,也可能都是0分,每个队伍将参加的场次得到的分数加起来,给你每个队伍最终得分,让你计算至少表演了几场. 思路 : ans = max(maxx,(sum+1)/2) :其实想想就可以,如果所有得分中最大值没有和的一半大,那就是队伍中一半一半对打,否则的话最大的那个就都包了. 1 #include <cstdio> 2 #include <cstring> 3 #include <st

2014多校第七场1005 || HDU 4939 Stupid Tower Defense (DP)

题目链接 题意 :长度n单位,从头走到尾,经过每个单位长度需要花费t秒,有三种塔: 红塔 :经过该塔所在单位时,每秒会受到x点伤害. 绿塔 : 经过该塔所在单位之后的每个单位长度时每秒都会经受y点伤害. 蓝塔 : 经过该塔所在单位之后,再走每个单位长度的时候时间会变成t+z. 思路 : 官方题解 : 1 #include <cstdio> 2 #include <cstring> 3 #include <iostream> 4 #define LL long long

2014多校第三场1005 || HDU 4891 The Great Pan(模拟)

题目链接 题意 : 给你n行字符串,问你有多少种理解方式.有两大类的理解 (1){A|B|C|D|...}代表着理解方式可以是A,可以是B或C或者D. (2)$blah blah$,在$$这两个符号中间,如果是不连续的空格的那个位置就有2种理解方式,可以理解为没有空格也可以理解为有空格.如果有连续N个空格的位置,那里就有N+1种理解方式. 最后所有的理解方式相乘,数据保证$一定与$匹配,{一定与匹配},不会有任何嵌套,类似{$$}或者{{}}或者${}$这种情况都不会出现,也不会有{$}这种情况

2014多校第五场1001 || HDU 4911 Inversion (归并求逆序数)

题目链接 题意 : 给你一个数列,可以随意交换两相邻元素,交换次数不超过k次,让你找出i < j 且ai > aj的(i,j)的对数最小是多少对. 思路 : 一开始想的很多,各种都想了,后来终于想出来这根本就是求逆序数嘛,可以用归并排序,也可以用树状数组,不过我们用树状数组做错了,也不知道为什么.求出逆序数来再减掉k次,就可以求出最终结果来了.求逆序数链接1,链接2 1 #include <stdio.h> 2 3 int left[250003], right[250003];