HDU 4930 Fighting the Landlords 斗地主模拟

于 2016-11-28 01:48:25 发布
阅读量421 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fawks96/article/details/53372970
版权

题目传送门：http://acm.hdu.edu.cn/showproblem.php?pid=4930
题意：虽然题目很长，但是其实就是一直在介绍我们很熟悉的斗地主规则。要求这一轮里是否A出牌后B没有牌可以压过A。
解题思路：这道题尤其要注意出牌的先后性，先处理先手一方的情况，因为它是先出牌的一方。如果先手（A）有王炸的优先级是最高的，最先处理这种情况，直接输出Yes。然后处理先手可以一次性打完手里的牌的情况，这种情况也是不用考虑后手（B）的情况直接输出Yes即可。
然后考虑其他的情况，即先手无法直接秒杀后手的情况，此时要具体考虑后手的牌的情况。这时后手里是否有王炸的优先级是最高的，如果有王炸直接输出No即可。然后我们处理B中有炸弹的情况，因为炸弹可以攻击任意的除了王炸外的出牌，比较AB中炸弹的大小（如果存在），如果B的炸弹大于A或者A没有炸弹，则B此轮压过A，输出No。如果B没有炸弹，进行下面的步骤：再接下来细分各种出牌的组合可能性，对应地一一比较大小，如果A有任一出牌组合大于B，则输出Yes，然后结束算法。因为A是先手，它有出牌的主动权，所以只要有任意一种出牌方式B没法接，即可打出这种方式，那么B一定没有牌可以接，故输出Yes。
AC代码：

/*****************************************
                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'   |     |//  `.
            /   |||  :  |||//  \
           /  _||||| -:- |||||-  \
           |   | \\  -  /// |   |
           |  _|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . __
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `-  `.;`\ _ /`;.`/ - ` : | |
     \  \ `-.    _ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         佛祖保佑       永无BUG
*****************************************/
#include<cstdio>
#include<cstring>
#include<map>
#include<algorithm>
using namespace std;
map<char,int> m;
map<char,int> cnt1;
map<char,int> cnt2;
int main()
{
    m['3'] = 1;
    m['4'] = 2;
    m['5'] = 3;
    m['6'] = 4;
    m['7'] = 5;
    m['8'] = 6;
    m['9'] = 7;
    m['T'] = 8;
    m['J'] = 9;
    m['Q'] = 10;
    m['K'] = 11;
    m['A'] = 12;
    m['2'] = 13;
    m['X'] = 14;
    m['Y'] = 15;
    int t;
    scanf("%d", &t);
    char str1[20];
    char str2[20];
    while (t--)
    {
        cnt1.clear();
        cnt2.clear();
        scanf("%s %s", str1, str2);
        int len1 = strlen(str1);
        int len2 = strlen(str2);
        for (int i = 0; i < len1; i++) cnt1[str1[i]]++;
        for (int i = 0; i < len2; i++) cnt2[str2[i]]++;
        if (cnt1['X'] && cnt1['Y'])
        {
            puts("Yes");
            continue;
        }
        //直接能打完获胜
        //1.单个
        if (len1 == 1)
        {
            puts("Yes");
            continue;
        }
        //2.对子
        if (len1 == 2 && str1[0] == str1[1])
        {
            puts("Yes");
            continue;
        }
        //3.3连
        if (len1 == 3 && cnt1[str1[0]] == 3)
        {
            puts("Yes");
            continue;
        }
        //4.三带一
        if (len1 == 4)
        {
            bool ok = false;
            for (int i = 0; i < len1; i++)
            {
                if (cnt1[str1[i]] >= 3)
                {
                    ok = true;
                    break;
                }
            }
            if (ok)
            {
                puts("Yes");
                continue;
            }
        }
        //5.三带二同
        if (len1 == 5)
        {
            bool ok = false;
            for (int i = 0; i < 5 && !ok; i++)
            {
                for (int j = 0; j < 5 && !ok; j++)
                {
                    if (i == j) continue;
                    if (str1[i] != str1[j] && ((cnt1[str1[i]] == 2 && cnt1[str1[j]] == 3) || (cnt1[str1[i]] == 3 && cnt1[str1[j]] == 2)))
                    {
                        ok = true;
                    }
                }
            }
            if (ok)
            {
                puts("Yes");
                continue;
            }
        }
        //6.四带二可不同
        if (len1 == 6)
        {
            bool ok = false;
            for (int i = 0; i < 6; i++)
            {
                if (cnt1[str1[i]] == 4)
                {
                    ok = true;
                    break;
                }
            }
            if (ok)
            {
                puts("Yes");
                continue;
            }
        }
        //7.王炸(已最先处理）
        //8.炸弹(包在4中了）
        //---------华丽丽的分割线---------//
        int r1 = -1;
        int r2 = -1;
        if (cnt2['X'] && cnt2['Y'])
        {
            puts("No");
            continue;
        }
        for (int i = 0; i < len2; i++)
        {
            if (cnt2[str2[i]] == 4)
            {
                r2 = max(r2,m[str2[i]]);
            }
        }
        if (r2 != -1)
        {
            for (int i = 0; i < len1; i++)
            {
                if (cnt1[str1[i]] == 4)
                {
                    r1 = max(r1,m[str1[i]]);
                }
            }
            if (r1 < r2)//r1 == -1 || r1 < r2
            {
                puts("No");
                continue;
            }
        }
        //1.单个
        r1 = -1;
        r2 = -1;
        for (int i = 0; i < len1; i++) r1 = max(r1,m[str1[i]]);
        for (int i = 0; i < len2; i++) r2 = max(r2,m[str2[i]]);
        if (r1 > r2)
        {
            puts("Yes");
            continue;
        }
        //2.对子
        if (len1 >= 2)
        {
            r1 = -1;
            r2 = -1;
            for (int i = 0; i < len1; i++)
            {
                if (cnt1[str1[i]] >= 2)
                {
                    r1 = max(r1,m[str1[i]]);
                }
            }
            if (r1 != -1 && len2 < 2)
            {
                puts("Yes");
                continue;
            }
            for (int i = 0; i < len2; i++)
            {
                if (cnt2[str2[i]] >= 2)
                {
                    r2 = max(r2,m[str2[i]]);
                }
            }
            if (r1 > r2)
            {
                puts("Yes");
                continue;
            }
        }
        //3.3连
        if (len1 >= 3)
        {
            r1 = -1;
            r2 = -1;
            for (int i = 0; i < len1; i++)
            {
                if (cnt1[str1[i]] >= 3)
                {
                    r1 = max(r1,m[str1[i]]);
                }
            }
            if (r1 != -1 && len2 < 3)
            {
                puts("Yes");
                continue;
            }
            for (int i = 0; i < len2; i++)
            {
                if (cnt2[str2[i]] >= 3)
                {
                    r2 = max(r2,m[str2[i]]);
                }
            }
            if (r1 > r2)
            {
                puts("Yes");
                continue;
            }
        }
        //4.三带一
        if (len1 >= 4)
        {
            r1 = -1;
            r2 = -1;
            for (int i = 0; i < len1; i++)
            {
                if (cnt1[str1[i]] == 3)
                {
                    r1 = max(r1,m[str1[i]]);
                }
            }
            if (r1 != -1 && len2 < 4)
            {
                puts("Yes");
                continue;
            }
            for (int i = 0; i < len2; i++)
            {
                if (cnt2[str2[i]] == 3)
                {
                    r2 = max(r2,m[str2[i]]);
                }
            }
            if (r1 > r2)
            {
                puts("Yes");
                continue;
            }
        }
        //5.三带二同
        if (len1 >= 5)
        {
            r1 = -1;
            r2 = -1;
            for (int i = 0; i < len1; i++)
            {
                for (int j = 0; j < len1; j++)
                {
                    if (i == j) continue;
                    if (str1[i] != str1[j])
                    {
                        if (cnt1[str1[i]] == 3 && cnt1[str1[j]] == 2)
                        {
                            r1 = max(r1,m[str1[i]]);
                        }
                        if (cnt1[str1[i]] == 2 && cnt1[str1[j]] == 3)
                        {
                            r1 = max(r1,m[str1[j]]);
                        }
                    }
                }
            }
            if (r1 != -1 && len2 < 5)
            {
                puts("Yes");
                continue;
            }
            for (int i = 0; i < len2; i++)
            {
                for (int j = 0; j < len2; j++)
                {
                    if (i == j) continue;
                    if (str2[i] != str2[j])
                    {
                        if (cnt2[str2[i]] == 3 && cnt2[str2[j]] == 2)
                        {
                            r2 = max(r2,m[str2[i]]);
                        }
                        if (cnt2[str2[i]] == 2 && cnt2[str2[j]] == 3)
                        {
                            r2 = max(r2,m[str2[j]]);
                        }
                    }
                }
            }
            if (r1 > r2)
            {
                puts("Yes");
                continue;
            }
        }
        //6.四带二可不同
        if (len1 >= 6)
        {
            r1 = -1;
            r2 = -1;
            for (int i = 0; i < len1; i++)
            {
                if (cnt1[str1[i]] == 4)
                {
                    r1 = max(r1,m[str1[i]]);
                }
            }
            if (r1 != -1 && len2 < 6)
            {
                puts("Yes");
                continue;
            }
            for (int i = 0; i < len2; i++)
            {
                if (cnt2[str2[i]] == 4)
                {
                    r2 = max(r2,m[str2[i]]);
                }
            }
            if (r1 > r2)
            {
                puts("Yes");
                continue;
            }
        }
        //7.王炸
        //8.炸弹
        if (len1 >= 4)
        {
            r1 = -1;
            r2 = -1;
            for (int i = 0; i < len1; i++)
            {
                if (cnt1[str1[i]] == 4)
                {
                    r1 = max(r1,m[str1[i]]);
                }
            }
            if (r1 != -1 && len2 < 4)
            {
                puts("Yes");
                continue;
            }
            for (int i = 0; i < len2; i++)
            {
                if (cnt2[str2[i]] == 4)
                {
                    r2 = max(r2,m[str2[i]]);
                }
            }
            if (r1 > r2)
            {
                puts("Yes");
                continue;
            }
        }
        puts("No");
    }
    return 0;
}
fawks96
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hdu 4930 Fighting the Landlords （模拟）
Coding A World
08-07 1033
Fighting the Landlords Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others) Total Submission(s): 160    Accepted Submission(s): 52 Problem Description Figh
hdu4930 Fighting the Landlords（模拟 多校6）
08-08 1306
hdu4930 Fighting the Landlords（模拟 多校6）
HDU 4930
xcszbdnl的专栏
08-07 504
直接模拟，先看能不能一手出完，不能一手出wan
HDU4930-Fighting the Landlords
懒人一枚。
08-07 781
题意：斗地主，就是要自己出牌，使得对手在这一轮无法出牌，或者有出牌的可能，但是你的牌已经走完了。如果符合这些条件的话，输出Yes，否则输出No。 思路：先预处理能直接把牌走完的情况，如果不行的话就直接暴力枚举能获胜的情况。 #include #include #include #include using namespace std; const int MAXN
hdu 4930 Fighting the Landlords(模拟)
不慌不忙、不急不躁
08-07 1192
题目连接：hdu 4930 Fighting the Landlords 题目大意：就是两个人玩斗地主，有8种牌型，单张，一对，三张，三带一，三带对，四带二，四炸，王炸。要求上家这一轮出牌下家管不上或者上家将牌走完则输出yes。 解题思路：总共就20张牌，枚举220种出牌方法，然后保留每种牌型的最大值，判断一下就可以了，注意细节。 #include #include #inclu
code_hdu.rar_ACM_The First_hdu_test case example
09-23
For a positive integer n, let’s denote function f(n,m) as the m-th smallest integer x that x>n and gcd(x,n)=1. For example, f(5,1)=6 and f(5,5)=11. You are given the value of m and (f(n,m)?n)⊕n,...
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
hdu1020.rar_hdu1020
09-20
这个题目要求参赛者编写一个程序，模拟一个猜数字的游戏过程，其中游戏规则相当简单：计算机随机选择一个介于1到N之间的整数，玩家有若干次机会猜测这个数字，每次猜测后，计算机会给出提示，告诉玩家猜的数字是偏大...
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
HDU 4930 斗地主模拟
Dan__ge的博客
07-14 406
点击打开链接 题意：给两个人的牌，第一个是地主的第二个是农民的，现在问你第一个这回合能否胜利，胜利条件是农民没有比地主出的大的牌或者地主将牌打光了，然后它的大小比较什么的上面给了与我们平时玩的没什么差别 思路：首要判断的就是地主这手牌能否打光，打光就直接yes了，然后判断王炸，若地主有就
HDU 4930 Fighting the Landlords （超级暴力+读懂题意）
n-1
08-08 936
斗地主！！不会玩这游戏，真得好好去学下，哈哈哈哈
hdu4930Fighting the Landlords（直接枚举）
08-08 722
题目：hdu4930Fighting the Landlords（直接枚举） 题目大意：给你两手牌，前面的是你的牌。问仅仅当前这一轮，你手中的牌可以赢吗？ 赢的条件：你手中的牌出完了，或者是你出的牌对方要不起。这里的规则和斗地主的基本是一致的，只是没有顺子。规则就不详述了。 解题思路：总共最多就17张牌，先判断是否有双飞，有就获胜。然后将每种不同种类的牌（单支和对子算不同种类
hdu 4930 模拟
Cugb->Baoge
08-08 503
模拟即可 #include #include #include #include #include #include using namespace std; mapp; char a[111],b[111]; int an[16],bn[16];//单张 int ad[16],bd[16];//对子 int as[16],bs[16];//三张 int asd[16][16],bsd[16][
HDU 4930 模拟题
The Summer, The Winter
08-08 728
额，这题当时我还觉得是博弈题。。。呵呵了就。
模拟斗地主——HDU 4930
大田二十
08-26 877
模拟斗地主
hdu 4930 Fighting the Landlords 多校第六场 斗地主纯模拟
ChasingWaves
08-08 446
//0MS 312K #include #include #include #include #include #include #include #include using namespace std; char a[25]; char b[25]; int pp(char k){ if(k=='T') return 10; else if(k=='J')
Crypto_30_vHsm_Types.h
07-09
Crypto_30_vHsm_Types
vmware虚拟机安装教程.pdf
最新发布
07-10
VMware虚拟机安装教程是一个详细且系统的过程，涵盖了从下载、安装到配置虚拟机的多个步骤。以下是一个详尽的VMware虚拟机安装教程，旨在帮助用户顺利搭建自己的虚拟环境。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值