【NOIP2015】斗地主（及加强版&原版）

最新推荐文章于 2021-01-26 08:02:40 发布
最新推荐文章于 2021-01-26 08:02:40 发布
阅读量2.4k 收藏 8
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 题解 搜索 dp 贪心 文章标签： c++ NOIP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38064038/article/details/78175870
本文探讨了基于斗地主游戏中牌局的算法问题，包括普通版、加强版及原版的不同规则下的最少出牌次数求解。文章通过搜索与贪心策略结合DP方法来优化解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题意

  给定一副牌，保证合法（即牌包括2，3，4，5，6，7，8，9，10，J，Q，K，A，王，并且每种牌不超过四张，王不超过两张），给定合法的出牌方案，求最少出牌次数。
  方案：
  ①.火箭，即双王
  ②.炸弹，即4张面值相同的牌
  ③.单张和对子
  ④.三不带，即3张面值相同的牌
  ⑤.三带一单或三带一对
  ⑥.单顺子，即面值连续的五张以上的牌
  ⑦.双顺子，基本同上
  ⑧.三顺子，基本同上
  ⑨.四带二单（包括四带一对）或四带二对（包括四带四，例如44445555就可以一次打出）

解法

搜索：
  可以考虑枚举所有方案进行搜索，然后加一个最优性剪枝
  首先，尽量将顺子处理完毕，因为顺子能够一次性解决掉大量的牌
  处理完顺子之后，就只剩下一些面值不连续的单张，对子，单张，炸弹。设x，y，z，w分别表示处理完顺子之后还剩下一张牌的面值数量，两张牌的……四张牌的数量
  那么我们可以对这些散牌进行贪心求解：
  首先进行四带二对，其次四带二单，再其次四带一对，随后是炸弹，紧跟着三带一对，三带一，三不带
  当z=0，w=0时，那么就可以用x+y次操作将单牌和对子打光
  但是在贪心的时候，可能会遇到一些问题，所以最好使用DP求解
  然后我们来看加强版：
  加强版与普通版的不同之处在于两个王不能当对子牌打出去，即没有三带两王这种出发，其他情况就差不多，因为两张王可以打出火箭，而四带一对王就是四带二单，所以只需要打一个标记：如果两张王均出现了，并且在三带二时对子牌只剩一对了，那就不能带
  接下来就是原版斗地主：
  原版斗地主出自一位NOI选手，是2014年联赛模拟题。基本题意类似，不同之处在于没有四带二单或四带二对，新增连三带一，即飞机+翅膀，连三带一中可以包含2或者大小王，但这些只能当做每个三带一中的“另外一张牌”：QQQKKKAAA222是一个合法的连三带一,但只能当做是QQQ2+KKK2+AAA2。
  
  所以我们可以将两张王拆开（如果两张王都有），然后看做单张牌（方便带），在最后如果还剩下两张以上的单牌，那么就x−2，y+1
  然后一个重点就是怎么处理连三带一中带的牌，有两种做法：
  ①.留到最后，用一个变量记录需要带多少张牌，在最后处理散牌时，按单牌，对子，三张，炸弹的顺序去填补要带的牌
  ②.在找到连三不带之后，另开一个函数，去枚举带哪些牌，注意一些细节和剪枝，也可以很快出解

复杂度

O（不知道）

代码
普通版：

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#define rg register
using namespace std;
bool tre,twi,onc;
int p[20];
int T,n,ans,zzl;
void cal(rg int step,rg int x,rg int y,rg int z,rg int w)
{
    if( step>ans || step+z+w>ans )   return ;
    if( !z && !w ) {   ans=min( ans,step+x+y );return ; }
    zzl++;
    if( w>0 )
    {
        if( x>=2 )   cal( step+1,x-2,y,z,w-1 );
        if( y>=2 )   cal( step+1,x,y-2,z,w-1 );
        if( y>=1 )   cal( step+1,x,y-1,z,w-1 );
        if( z>=1 )   cal( step+1,x+1,y,z-1,w-1 );
        if( w>=2 )   cal( step+1,x,y,z,w-2 ),cal( step+1,x,y+1,z,w-2 );
        cal( step+1,x,y,z,w-1 );
        return ;
    }
    if( z>0 )
    {
        if( w>=1 )   cal( step+1,x,y+1,z-1,w-1 );
        if( x>=1 )   cal( step+1,x-1,y,z-1,w );
        else
            if( y>=1 )   cal( step+1,x,y-1,z-1,w );
            else   ans=min( ans,step+z );
        return ;
    }
}
void dfs(int step)
{
    if( step>ans )   return ;
    if( tre )
    {
        for(int i=3,j;i<=13;i++)
            if( p[i]>=3 )
            {
                for(j=i+1;j<=14;j++)   if( p[j]<=2 )   break ;
                if( j-i>=2 )
                    for(int l=i;l+1<=j-1;l++)
                        for(int r=l+1;r<=j-1;r++)
                        {
                            for(int h=l;h<=r;h++)   p[h]-=3;
                            dfs( step+1 );
                            for(int h=l;h<=r;h++)   p[h]+=3;
                        }
                i=j;
            }
    }
    if( twi )
    {
        for(int i=3,j;i<=13;i++)
            if( p[i]>=2 )
            {
                for(j=i+1;j<=14;j++)   if( p[j]<=1 )   break ;
                if( j-i>=3 )
                    for(int l=i;l+2<=j-1;l++)
                        for(int r=l+2;r<=j-1;r++)
                        {
                            for(int h=l;h<=r;h++)   p[h]-=2;
                            dfs( step+1 );
                            for(int h=l;h<=r;h++)   p[h]+=2;
                        }
                i=j;
            }
    }
    if( onc )
    {
        for(int i=3,j;i<=13;i++)
            if( p[i]>=1 )
            {
                for(j=i+1;j<=14;j++)   if( !p[j] )   break ;
                if( j-i>=5 )
                    for(int k=i;k+4<=j-1;k++)
                        for(int l=k+4;l<=j-1;l++)
                        {
                            for(int h=k;h<=l;h++)   p[h]-=1;
                            dfs( step+1 );
                            for(int h=k;h<=l;h++)   p[h]+=1;
                        }
                i=j;
            }
    }
    if( step>ans )   return;
    int x,y,z,w;
    x=y=z=w=0;
    for(int i=0;i<=14;i++)
        if( p[i] )
        {
            if( p[i]==1 )   x++;
            if( p[i]==2 )   y++;
            if( p[i]==3 )   z++;
            if( p[i]==4 )   w++;
        }
    cal( step,x,y,z,w );
}
int main()
{
    int x,y;
    scanf("%d%d",&T,&n);
    while( T-- )
    {
        memset( p,0x0,sizeof p );
        ans=n;tre=twi=onc=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&y,&x);
            if( y==1 )   y=14;
            p[y]++;
        }
        for(int i=3,j;i<=13;i++)
            if( p[i]>=3 )
            {
                for(j=i+1;j<=14;j++)   if( p[j]<3 )   break ;
                if( j-i>=2 )   tre=1;
            }
        for(int i=3,j;i<=13;i++)
            if( p[i]>=2 )
            {
                for(j=i+1;j<=14;j++)   if( p[j]<2 )   break ;
                if( j-i>=3 )   twi=1;
            }
        for(int i=3,j;i<=13;i++)
            if( p[i]>=1 )
            {
                for(j=i+1;j<=14;j++)   if( !p[j] )   break ;
                if( j-i>=5 )   onc=1;
            }
        dfs( 0 );
        printf("%d\n",ans);
    }
    return 0;
}

加强版：没有，可以按着上面改
原版：

#include<iostream>
#include<cstdlib>
#include<cstdio>
#define Rint register int
using namespace std;
bool tre,twi,onc,tre_1;
bool flag;
int p[30],use[30];
int ans;
void cal(Rint step,Rint x,Rint y,Rint z,Rint w)
{
    if( step+z+w>=ans )   return ;
    if( !z && !w )
    {
        if( x>=2 && flag )   x--;//大小王当对子牌
        ans=min( ans,step+x+y );return ;//单牌+对子打完
    }
    if( w>0 )   cal( step+1,x,y,z,w-1 );//炸弹（三带一）
    if( z>0 )
    {
        if( x>0 )   cal( step+1,x-1,y,z-1,w );//三带一
        if( y>0 )   cal( step+1,x,y-1,z-1,w );//三带二
        if( !x && !y )   ans=min( ans,step+z+w );//三不带+炸弹打完
    }
}
void dfs(Rint step);
void work(Rint k,Rint sum,Rint step);
int main()
{
    freopen("landlords.in","r",stdin);
    freopen("landlords.out","w",stdout);
    char s[20];
    while( scanf("%s",s)!=EOF )
    {
        ans=17;
        tre_1=tre=twi=onc=0;
        for(int i=0;i<=16;i++)   p[i]=0;
        for(int i=0,x;i<=16;i++)
        {
            if( s[i]>='2' && s[i]<='9' )   x=s[i]-'0';
            else   if( s[i]=='0' )   x=10;
            else   if( s[i]=='J' )   x=11;
            else   if( s[i]=='Q' )   x=12;
            else   if( s[i]=='K' )   x=13;
            else   if( s[i]=='A' )   x=14;
            else   if( s[i]=='*' )   x=15;
            else   if( s[i]=='#' )   x=16;
            p[x]++;
        }
        flag=p[15]&p[16];
        for(int i=3,j;i<=13;i++)
        {
            if( p[i]<3 )   continue ;
            for(j=i+1;j<=14;j++)   if( p[j]<3 )   break ;
            if( j-i>=2 )   tre_1=1;
        }   
        for(int i=3,j;i<=13;i++)
        {
            if( p[i]<3 )   continue ;
            for(j=i+1;j<=14;j++)   if( p[j]<3 )   break ;
            if( j-i>=2 )   tre=1;
        }
        for(int i=3,j;i<=13;i++)
        {
            if( p[i]<2 )   continue ;
            for(j=i+1;j<=14;j++)   if( p[j]<2 )   break ;
            if( j-i>=3 )   twi=1;
        }
        for(int i=3,j;i<=13;i++)
        {
            if( p[i]<1 )   continue ;
            for(j=i+1;j<=14;j++)   if( p[j]<1 )   break ;
            if( j-i>=5 )   onc=1;
        }
        dfs( 0 );
        printf("%d\n",ans);
    }
    return 0;
}
void work(Rint k,Rint sum,Rint step)
{
    if( k>16 )   return ;
    if( !sum )   { dfs( step+1 );return ; }
    if( sum>=p[k] )
    {
        int tmp=p[k];
        p[k]=0;
        work( k+1,sum-tmp,step );
        p[k]=tmp;
    }
    else
    {
        p[k]-=sum;
        work( k+1,0,step );
        p[k]+=sum;
    }
    work( k+1,sum,step );
}
void dfs(Rint step)
{
    if( step>=ans )   return ;
    if( tre_1 )//连三带一
    {
        for(int i=3,j;i<=13;i++)
        {
            if( p[i]<3 )   continue ;
            for(j=i+1;j<=14;j++)   if( p[j]<3 )   break ;
            if( j-i>=2 )
            {
                for(int k=i;k+1<=j-1;k++)
                    for(int l=k+1;l<=j-1;l++)
                    {
                        for(int m=k;m<=l;m++)   p[m]-=3;
                        work( 2,l-k+1,step );
                        for(int m=k;m<=l;m++)   p[m]+=3;
                    }
            }
            i=j;
        }
    }
    if( step>=ans )   return;
    if( tre )//三顺子
    {
        for(int i=3,j;i<=13;i++)
        {
            if( p[i]<3 )   continue ;
            for(j=i+1;j<=14;j++)   if( p[j]<3 )   break ;
            if( j-i>=2 )
            {
                for(int k=i;k+1<=j-1;k++)
                    for(int l=k+1;l<=j-1;l++)
                    {
                        for(int m=k;m<=l;m++)   p[m]-=3;
                        dfs( step+1 );
                        for(int m=k;m<=l;m++)   p[m]+=3;
                    }
            }
            i=j;
        }
    }
    if( step>=ans )   return;
    if( twi )//双顺子
    {
        for(int i=3,j;i<=13;i++)
        {
            if( p[i]<2 )   continue ;
            for(j=i+1;j<=14;j++)   if( p[j]<2 )   break ;
            if( j-i>=3 )
            {
                for(int k=i;k+2<=j-1;k++)
                    for(int l=k+2;l<=j-1;l++)
                    {
                        for(int m=k;m<=l;m++)   p[m]-=2;
                        dfs( step+1 );
                        for(int m=k;m<=l;m++)   p[m]+=2;
                    }
            }
            i=j;
        }
    }
    if( step>=ans )   return;
    if( onc )//单顺子
    {
        for(int i=3,j;i<=13;i++)
        {
            if( p[i]<1 )   continue ;
            for(j=i+1;j<=14;j++)   if( p[j]<1 )   break ;
            if( j-i>=5 )
            {
                for(int k=i;k+4<=j-1;k++)
                    for(int l=k+4;l<=j-1;l++)
                    {
                        for(int m=k;m<=l;m++)   p[m]--;
                        dfs( step+1 );
                        for(int m=k;m<=l;m++)   p[m]++;
                    }
            }
            i=j;
        }
    }
    if( step>=ans )   return;
    int x,y,z,w;
    x=y=z=w=0;
    for(int i=2;i<=16;i++)
    {
        if( p[i]==1 )   x++;
        if( p[i]==2 )   y++;
        if( p[i]==3 )   z++;
        if( p[i]==4 )   w++;
    }
    cal( step,x,y,z,w );
}
[NOIP2015] 斗地主
蒟蒻QTY
07-30 514
有这一张图片就够了，原来考虑用状压，但会超时。。所以果断大暴搜。。→ _→     率先搜顺子，三，四带几，注：四个二带俩王，四个A带对二加对二，都是非法的。。     走牌快的弄完后，把单出4,3,2,1一次性加上。     改这道题时，机房里有一群人在喊“俩王”，“仨四带二”。。感觉真有人在玩。。。#include #include #include #include #inclu
洛谷P2668 [NOIP 2015 提高组] 斗地主
最新发布
yjfyjfyjf54188的博客
06-23 961
现在，牛牛只想知道，对于自己的若干组手牌，分别最少需要多少次出牌可以将它们打光。游戏者每次可以根据规定的牌型进行出牌，首先打光自己的手牌一方取得游戏的胜利。需要注意的是，本题中游戏者每次可以出手的牌型与一般的斗地主相似而略有不同。，而花色并不对牌的大小产生影响。表示牌的花色，中间用空格隔开。，表示手牌的组数以及每组手牌的张数。数据保证：所有的手牌都是随机生成的。，深搜出牌次数，枚举每次打出的牌。顺子的思路都差不多，首先枚举顺子的。行，每行一个整数，表示打光第。，如果可以则打出去，深搜下一层，
2015noip 斗地主
weixin_30823683的博客
08-01 295
斗地主 题目描述 牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片的A到K加上大小王的共54张牌来进行的扑克牌游戏。在斗地主中，牌的大小关系根据牌的数码表示如下：3&lt;4&lt;5&lt;6&lt;7&lt;8&lt;9&lt;10&lt;J&lt;Q&lt;K&lt;A&lt;2&lt;小王&lt;大王，而花色并不...
bzoj 4325: NOIP2015 斗地主 （dfs+剪枝）
clover_hxy的博客
10-27 656
4325: NOIP2015 斗地主 Time Limit: 30 Sec  Memory Limit: 1024 MB Submit: 638  Solved: 424 [Submit][Status][Discuss] Description  牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片的A到K加上大小王的共54张牌来进行的扑克牌游戏。在斗地主中
【搜索】NOIP2015斗地主
zhanxufeng的博客
10-12 1744
题目链接：洛谷2668 题目描述 牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片的A到K加上大小王的共54张牌来进行的扑克牌游戏。在斗地主中，牌的大小关 系根据牌的数码表示如下：3&amp;lt;4&amp;lt;5&amp;lt;6&amp;lt;7&amp;lt;8&amp;lt;9&amp;lt;10&amp;lt;J&amp;lt;Q&amp;lt;K&amp;lt;A&amp;lt;2&amp;lt;小王&amp;lt;大王，而花色并不对牌的大小产生影响。每一局游
【NOIP2015提高组Day1】斗地主
zhy_Learn的博客
01-19 801
嘿嘿，学老贺乱搞 文章目录题面![在这里插入图片描述](https://img-blog.csdnimg.cn/20210119211633781.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poeV9MZWFybg==,size_16,color_FFFFFF,t_70#pic_center)心路历程题解官方版本代码彭奆版本本人解法代码 题面.
noip2015初赛普及组答案分析.pdf
06-07
### NOIP2015初赛普及组答案分析 #### 单项选择题解析 **1. 计算机内部的运算方式** - **知识点**：计算机内部采用二进制进行数据处理。 - **解析**：计算机硬件系统采用二进制进行数据表示和运算，这是因为二...
noip2015普及组初赛试题+答案.pdf
06-07
### NOIP2015普及组初赛试题分析 #### 一、单项选择题解析 1. **1MB等于（D. 1024 X 1024 字节）** - **知识点**: 计算机存储单位换算。 - **解析**: 在计算机科学中，1MB（兆字节）等于1024KB，1KB（千字节）...
NOIP2015提高组复赛数据
06-12
&quot;NOIP2015提高组复赛数据&quot;这个标题指的是全国青少年信息学奥林匹克联赛（National Olympiad in Informatics in Provinces，简称NOIP）2015年比赛的提高组复赛的数据集。NOIP是一项面向中学生的计算机编程竞赛，旨在...
【NOIP2015】斗地主题解
wspzz5的博客
07-05 1256
先给这两条评论点个赞： 表示做大贪心大膜你时有同感。。 题面： 2106. [NOIP2015] 斗地主 ★★★☆   输入文件：landlords.in   输出文件：landlords.out   简单对比 时间限制：2 s   内存限制：1025 MB 【题目描述】 牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片
NOIP2015普及组初赛Pascal试题
08-12
NOIP（全国青少年信息学奥林匹克竞赛）是中国面向高中及初中学生的计算机学科竞赛，旨在激发学生对计算机科学的兴趣，培养学生的计算思维和解决问题的能力。NOIP分为普及组和提高组，普及组主要面向初中学生，提高组...
斗地主[NOIP2015]
weixin_33786077的博客
07-30 158
题目描述 牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片的A到K加上大小王的共54张牌来进行的扑克牌游戏。在斗地主中，牌的大小关系根据牌的数码表示如下：3&lt;4&lt;5&lt;6&lt;7&lt;8&lt;9&lt;10&lt;J&lt;Q&lt;K&lt;A&lt;2&lt;小王&lt;大王，而花色并不对牌的大小产生影响。每一局游戏中，一副手牌...
【noip 2015】斗地主
Hellsegamosken
08-14 659
题目描述 牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片的A到K加上大小王的共54张牌来进行的扑克牌游戏。在斗地主中，牌的大小关系根据牌的数码表示如下：>3<4<5<6<7<8<9<10#include<cstdio> #include<iostream> #include<algorithm> #include<cstring> using namespac
[LOJ2422]【NOIP2015】斗地主
weixin_30486037的博客
10-29 172
大名鼎鼎的NOIP2015D1T3 题意： 由于一些众所周知的原因，没有完整题面…… 给你一副斗地主的手牌（牌数&lt;=23），问最少要几次能出完； 包含双王，没有癞子，连对要三连对以上，可以直接出三张同点数的牌（三对），可以出连着的三对，也可以三带一，三带二，但不能出飞机，可以四张带一对或两张单牌。 题解： 神题啊……orz……虽然写起来并不麻烦，但是当年这个神之题面真是雷倒了无数...
【搜索】NOIP2015斗地主（增强版）
zhanxufeng的博客
10-24 1123
题目链接：洛谷2540 题目描述 牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片的A到K加上大小王的共54张牌来进行的扑克牌游戏。在斗地主中，牌的大小关系根据牌的数码表示如下：3&amp;lt;4&amp;lt;5&amp;lt;6&amp;lt;7&amp;lt;8&amp;lt;9&amp;lt;10&amp;lt;J&amp;lt;Q&amp;lt;K&amp;lt;A&amp;lt;2&amp;lt;小王&amp;lt;大王，而花色并不对牌的大小产生影响。每一局游戏
BZOJ 4325: NOIP2015 斗地主
Doleful Aria
05-28 1568
斗地主是偏题
noip 2015 斗地主 大爆搜！！！
Ren_Ivan的博客
07-31 405
反正肯定是大模拟 但是每一个可以出的牌都搜一定不是最优的 考虑最特殊的出牌方案：顺子（单，对，三） 每一种方案再加上暴力贪心打出剩下的牌的步数 #include #include #include #include #include #define N 35 using namespace std; int a[N],num[N],n,T,ANS; void read(){ int
NOIP2015提高组Day1斗地主
Andy&Calrn的博客
12-06 5557
题目分析仔细看，这道题着实想不到什么优美的算法，那么基本确定方向——dfs。 先分析，这题的花色是没用的 我们再分析，会发现这题的出牌顺序是不影响答案的 那么我们便可以先出牌多的（因为这样答案便会先便小，那么便可以方便后面的剪枝） 也就是我们先打顺子再打带牌！ 顺子是没有什么技巧的，便直接暴搜（当然也是先暴搜长度长的） 带牌是有技巧的！ 我们发现带牌是不与牌本身的点数有关的， 于是我
【NOIP2015提高组Day 1】斗地主
DY-hzx的博客
01-26 494
Description Input Output solution 这道题就是一道极其恶心的码农题，同样很多细节（第一次不想玩斗地主），挑起来很费劲，要注意细节，具体方法在下面的代码里。 code #include&lt;bits/stdc++.h&gt; using namespace std; int T,n,a[20],ans,kk; void dfs(int sum) { if(sum&gt;ans) return; int bz=0; int k=0; for(int i=1;i&l
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值