【NOIP2015提高组Day1】斗地主

最新推荐文章于 2025-09-24 23:07:23 发布

原创最新推荐文章于 2025-09-24 23:07:23 发布 · 761 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

题解专栏收录该内容

7 篇文章

订阅专栏

本文介绍了一种用于斗地主游戏中牌型组合优化的算法。通过建立四维动态规划模型来解决手牌如何最优组合的问题，并进一步考虑了顺子等特殊情况。最终实现了在限定时间内找到最优解的目标。

这里写图片描述

输入1：
1 8
7 4
8 4
9 1
10 4
11 1
5 1
1 4
1 1
输入2：
1 17
12 3
4 3
2 3
5 4
10 2
3 3
12 2
0 1
1 3
10 1
6 2
12 1
11 3
5 2
12 4
2 2
7 2

输出1：
3
输出2：
6

小结

比赛时我以为这是一道要码很长的一道题，但是其实正解只有83行。
比赛时打了一个173行的程序，还没有加各种顺子。只得了30分。
那么总结一下：
首先我们设 $f[i][j][k][l]$ 表示只有一张牌的有i种，只有两张牌的有j种，只有三张牌的有k种，只有四张牌的有l种。这样，我们用一个 $O(n^4)$ 的暴力与处理出所有这些情况。
大概是这样：

memset(f,127,sizeof(f));
    f[0][0][0][0]=0;
    for (i=0;i<=n;++i)
        for (j=0;j<=n;++j)
            for (k=0;k<=n;++k)
                for (l=0;l<=n;++l)
                {
                    if(i+j*2+k*3+l*4>n) continue;
                    f[i][j][k][l]=i+j+k+l;
                    if(i) f[i][j][k][l]=min(f[i][j][k][l],f[i-1][j][k][l]+1);//Single
                    if(j) f[i][j][k][l]=min(f[i][j][k][l],f[i][j-1][k][l]+1);//Double
                    if(k)
                    {
                        f[i][j][k][l]=min(f[i][j][k][l],f[i][j][k-1][l]+1);//Triple
                        if(i-1>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i-1][j][k-1][l]+1);//Triple&Single
                        if(j-1>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i][j-1][k-1][l]+1);//Triple&Double
                    }
                    if(l) 
                    {
                        f[i][j][k][l]=min(f[i][j][k][l],f[i][j][k][l-1]+1);//Fourfold
                        if(i-2>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i-2][j][k][l-1]+1);//Fourfold&Double_Single
                        if(j-2>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i][j-2][k][l-1]+1);//Fourfold&Double_Double
                        if(j-1>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i][j-1][k][l-1]+1);//Fourfold&Double
                    }
                }

然后就可以处理顺子了。
我们用dfs枚举每种顺子的情况，因为鬼不可以被用来做顺子，所以要特殊判断一下。
具体看标：

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int T,n,x,ans;
int a[30],num[30],p[5];
int f[30][30][30][30]; 
int s[4]={0,5,3,2};
int get(int Joker,int x1,int x2,int x3,int x4)
{
    if(Joker==0) return f[x1][x2][x3][x4];
    if(Joker==1) return f[x1+1][x2][x3][x4];
    if(Joker==2) return (f[x1+2][x2][x3][x4],f[x1][x2][x3][x4]+1);
}
void dfs(int step)
{
    if(step>ans) return;
    memset(p,0,sizeof(p));
    for (int i=2;i<=14;++i)++p[num[i]];
    ans=min(ans,step+get(num[0],p[1],p[2],p[3],p[4]));
    int i,j,k,l;
    for (i=1;i<=3;++i)
    {
        for (j=3;j<=14;++j)
        {
            for (k=j;k<=14;++k)
            {
                if(num[k]<i) break;
                num[k]-=i;
                if(k-j+1>=s[i]) dfs(step+1);
            }
            for (l=k-1;l>=j;--l) num[l]+=i;
        }
    }
}
int main()
{
    freopen("landlords.in","r",stdin);
    freopen("landlords.out","w",stdout);
    scanf("%d%d",&T,&n);
    int i,j,k,l;
    memset(f,127,sizeof(f));
    f[0][0][0][0]=0;
    for (i=0;i<=n;++i)
        for (j=0;j<=n;++j)
            for (k=0;k<=n;++k)
                for (l=0;l<=n;++l)
                {
                    if(i+j*2+k*3+l*4>n) continue;
                    f[i][j][k][l]=i+j+k+l;
                    if(i) f[i][j][k][l]=min(f[i][j][k][l],f[i-1][j][k][l]+1);//Single
                    if(j) f[i][j][k][l]=min(f[i][j][k][l],f[i][j-1][k][l]+1);//Double
                    if(k)
                    {
                        f[i][j][k][l]=min(f[i][j][k][l],f[i][j][k-1][l]+1);//Triple
                        if(i-1>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i-1][j][k-1][l]+1);//Triple&Single
                        if(j-1>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i][j-1][k-1][l]+1);//Triple&Double
                    }
                    if(l) 
                    {
                        f[i][j][k][l]=min(f[i][j][k][l],f[i][j][k][l-1]+1);//Fourfold
                        if(i-2>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i-2][j][k][l-1]+1);//Fourfold&Double_Single
                        if(j-2>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i][j-2][k][l-1]+1);//Fourfold&Double_Double
                        if(j-1>=0)f[i][j][k][l]=min(f[i][j][k][l],f[i][j-1][k][l-1]+1);//Fourfold&Double
                    }
                }
    while (T--)
    {
        memset(num,0,sizeof(num));
        for (i=1;i<=n;++i)
        {
            scanf("%d%d",&a[i],&x);
            if(a[i]==1)++num[14];
            else ++num[a[i]];
        }ans=n;
        dfs(0);
        printf("%d\n",ans);
    }
}