NOIP2015 斗地主

题目描述

 牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、方片的A到K加上大小王的共54张牌来进行的扑克牌游戏。在斗地主中，牌的大小关系根据牌的数码表示如下：3<4<5<6<7<8<9<10<J<Q<K<A<2<小王<大王，而花色并不对牌的大小产生影响。每一局游戏中，一副手牌由n张牌组成。游戏者每次可以根据规定的牌型进行出牌，首先打光自己的手牌一方取得游戏的胜利。现在，牛牛只想知道，对于自己的若干组手牌，分别最少需要多少次出牌可以将它们打光。请你帮他解决这个问题。需要注意的是，本题中游戏者每次可以出手的牌型与一般的斗地主相似而略有不同。具体规则如下：

输入

第一行包含用空格隔开的2个正整数T,N，表示手牌的组数以及每组手牌的张数。

接下来T组数据，每组数据N行，每行一个非负整数对Ai,Bi，表示一张牌，其中Ai表示牌的数码,Bi表示牌的花色，中间用空格隔开。特别的，我们用1来表示数码A，11表示数码J，12表示数码Q，13表示数码K；黑桃、红心、梅花、方片分别用1-4来表示；小王的表示方法为01，大王的表示方法为02。

 

输出

共T行，每行一个整数，表示打光第T组手牌的最少次数。

样例输入

1 8
7 4
8 4
9 1
10 4
11 1
5 1
1 4
1 1

样例输出

3
solution：

1. 在第一眼看到这道题的时候，马上的感觉就是复杂。情况种类太多以至于貌似无法分类，从而导致无从下手的状态。
2. 但是，我们仔细回想一下问题所在，出牌的主要特征有两种，一种是顺子，一种是重复牌。
3. 对于重复牌，有两种主要的出法：第一，直接出牌，第二，带着一些其他的牌。
4. 那么，我们可以考虑将重复牌和顺子分类进行处理。
5. 对于每一种牌的个数预处理出来，把牌的优先级简化一下，变成1~14（注意这里大小王不能区分开！因为大小王可以组成对子，他们两个是没有优先级的区别的！）
6. 深搜查找情况，在深搜中进行对顺子的枚举的处理，我们知道，对于每一个不同的顺子形成的状态，都有一个最少操作数的重复牌的操作和它相互满足。
7. 即，顺子和对子的操作数加起来。正好能将所有的牌都出完。
8. 深搜中枚举可行的顺子，然后在每一次深搜的时候，处理出了这些顺子之后对应的重复牌的情况，相加，即为当前操作数的总和。
9. 另外，附带一句，对于重复牌的操作，一个单牌也算在重复牌操作中。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
__attribute__((optimize("O3")))int read() {
    int s=0,f=1;
    char ch=getchar();
    while(ch>'9'||ch<'0') {
        if(ch=='-') {
            f=-1;
        }
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') {
        s=(s<<1)+(s<<3)+(ch^48);
        ch=getchar();
    }
    return s*f;
}
int T,n,kind[25],ans,num[25];
__attribute__((optimize("O3")))int get(int x) {
    int temp=0;
    if(x==1) {
        temp=12;
    } else {
        if(x==2) {
            temp=13;
        } else {
            if(x==0) {
                temp=14;
            } else {
                if(x>=3&&x<=13) {
                    temp=x-2;
                }
            }
        }
    }
    return temp;
}
__attribute__((optimize("O3")))int card() {
    int b[6]= {0},ans=0;
    for(int i=1; i<=15; i++) {
        b[kind[i]]++;
    }
    while(b[4]&&b[2]>=2) {
        ans++;
        b[4]--;
        b[2]-=2;
    }
    while(b[4]&&b[1]>=2) {
        ans++;
        b[4]--;
        b[1]-=2;
    }
    while(b[3]&&b[1]>=1) {
        ans++;
        b[3]--;
        b[1]--;
    }
    while(b[3]&&b[2]>=1) {
        ans++;
        b[3]--;
        b[2]--;
    }
    ans+=b[1]+b[2]+b[3]+b[4];
    return ans;
}
__attribute__((optimize("O3")))void dfs(int step) {
    if(step>ans) {
        return ;
    }
    int x=card();
    ans=min(step+x,ans);
    for(int i=1; i<=11; i++) {
        int j;
        for(j=i; kind[j]>=3&&j<=12; j++);
        if(j-i<2) {
            continue;
        }
        for(int k=j; k-i>=2; k--) {
            for(int h=i; h<k; h++) {
                kind[h]-=3;
            }
            dfs(step+1);
            for(int h=i; h<k; h++) {
                kind[h]+=3;
            }
        }
    }
    for(int i=1; i<=10; i++) {
        int j;
        for(j=i; kind[j]>=2&&j<=12; j++);
        if(j-i<3) {
            continue;
        }
        for(int k=j; k-i>=3; k--) {
            for(int h=i; h<k; h++) {
                kind[h]-=2;
            }
            dfs(step+1);
            for(int h=i; h<k; h++) {
                kind[h]+=2;
            }
        }
    }
    for(int i=1; i<=8; i++) {
        int j;
        for(j=i; kind[j]>=1&&j<=12; j++);
        if(j-i<5) {
            continue;
        }
        for(int k=j; k-i>=5; k--) {
            for(int h=i; h<k; h++) {
                kind[h]--;
            }
            dfs(step+1);
            for(int h=i; h<k; h++) {
                kind[h]++;
            }
        }
    }
}
__attribute__((optimize("O3")))int main() {
    T=read();
    n=read();
    while(T--) {
        ans=0x7ffffff;
        memset(kind,0,sizeof(kind));
        for(int i=1; i<=n; i++) {
            int x=read(),y=read();
            int ji=get(x);
            kind[ji]++;
            //cout<<ji<<endl;
        }
        ans=card();
        dfs(0);
        printf("%d\n",ans);
    }
    return 0;
}