$[\ ZJOI\ 2006\ ]\ Mahjong$

$\\$

$Description$

现有权值分别为$1\text~100$的$100$种牌，分别给出每种排的张数$A_i$，试判断能否胡牌，胡牌需要将所有牌不重不漏地分成以下几类：

三张或四张相同的牌

权值连续的三张牌

两张相同的牌，这一类必须要有，而且只能有一个

一组数据共需要$N$次判断，胡了输出“$Yes$”，否则输出"$No$"。

$N\in [1,100]$，$A_i\in [0,100]$

$\\$

$Solution$

没有写贪心，但是找到了两种$DP$的方式，按照便于理解的顺序介绍：

$\\$

$\text O(N\times 100^3)$：

注意到每张牌只会影响到周围至多三种牌的出牌，而两两关系又可以互相导出，所以设$f[i][j][k][0/1]$表示，当前处理到第$i$种牌，第$i-1$种牌出了$j$张，第$i$种牌出了$k$张，有$/$没有计算过对子，其余更靠前的牌全部出完是否可行，至于保证全部出完，后面再给证明。有显然的初始化$f[0][0][0][0]=1$。

对于对子有特殊转移：

 if(k>1) f[i][j][k][1]|=f[i][j][k-2][0];

当前成立一个三张相同的牌，注意对子部分只能从相同的种类转移：
```
if(k>2) {f[i][j][k][1]|=f[i][j][k-3][1];f[i][j][k][0]|=f[i][j][k-3][0];}
```

当前成立一个四张相同的牌，讨论相同:

if(k>3) {f[i][j][k][1]|=f[i][j][k-4][1];f[i][j][k][0]|=f[i][j][k-4][0];}

注意到上面三种只对当前有要求，而成立三张连续的将会关系到前后的答案，因为确定后面的影响很不方便，我们不妨设三张连续的当前位置只考虑以当前的牌结束的部分。同样的，因为不便于考虑出多少组三张连续的牌，但注意到转移过程中会逐层转移自之前的情况，所以最优组合方案无需枚举，我们直接令当前的牌全部用于出连续三个一组的类型。同时为了保证除掉当前两种前面的全部都出完，所以向前找状态时默认第$i-2$种牌全部出完：
```
if(j>=k&&a[i-2]>=k){
    f[i][j][k][1]|=f[i-1][a[i-2]-k][j-k][1];
    f[i][j][k][0]|=f[i-1][a[i-2]-k][j-k][0];
}
```
答案即为$f[100][A_{99}][A_{100}][1]$是否为真。

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 1010
#define R register
#define gc getchar
using namespace std;

int a[N];
bool f[N][N][N][2];

inline int rd(){
  int x=0; bool f=0; char c=gc();
  while(!isdigit(c)){if(c=='-')f=1;c=gc();}
  while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=gc();}
  return f?-x:x;
}

int main(){
  int t=rd();
  while(t--){
    for(R int i=1;i<=100;++i) a[i]=rd();
    memset(f,0,sizeof(f)); f[0][0][0][0]=1;
    for(R int i=1;i<=100;++i)
      for(R int j=0;j<=100;++j)
        for(R int k=0;k<=100;++k){
          if(k>1)f[i][j][k][1]|=f[i][j][k-2][0];
          if(k>2){f[i][j][k][1]|=f[i][j][k-3][1];f[i][j][k][0]|=f[i][j][k-3][0];}
          if(k>3){f[i][j][k][1]|=f[i][j][k-4][1];f[i][j][k][0]|=f[i][j][k-4][0];}
          if(j>=k&&a[i-2]>=k){
            f[i][j][k][1]|=f[i-1][a[i-2]-k][j-k][1];
            f[i][j][k][0]|=f[i-1][a[i-2]-k][j-k][0];
          }
        }
    puts(f[100][a[99]][a[100]][1]?"Yes":"No");
  }
  return 0;
}

$\\$

$\Theta(N\times 100\times 3^3)$：

思路相同，但转化成了分别讨论相同的牌和连续的牌不同的出法。
注意到其实两类之间是可以互相转换的，具体地说，对于连续三张的出法，一样的三张牌的组成超过三组就是没意义的了，因为它完全可以拆成三张牌独立出各自的一套，剩下的再组成三张连续出的方法，例如五组相同的组成$(5\times 3)$就可以拆成三种牌各自出一套再加上两组$(3\times 3\times 1+2\times3)$，或三种牌各自出一套四张一族的，再加上一组$(3\times 4\times 1+1\times 3)$。我们发现，去掉所有的连续三张一组的部分以及一对的部分，如果剩下的每一类牌的数量都可以表示成$3x+4y$的形式，那么这个方案就是合法的。
于是状态就能神奇的设计为（以下称相同的牌三个或四个一组的为一套，称连续三张一组的为顺），$f[i][0/1/2][0/1/2][0/1]$表示当前处理到第$i$张牌，以第$i-1$张牌开始的顺出了$0/1/2$个，以第$i$张牌开始的顺出了$0/1/2$个，第$i-1$种和第$i$种其他的牌全部出成套，没出$/$出过对子的状态是否合法。同样有显然初始化$f[0][0][0][0]=1$，注意预处理出所有能表示成形如$3x+4y$形式的数。
转移考虑以第$i+1$个数为开始出了$s$个顺，注意要从合法的状态扩展，此时第$i+1$种牌剩余出成套的数即为$A_{i+1}-j-k-s$，若该数字查表合法则转移。
关于$0/1$状态间的转移，只需在每次枚举到$0$状态之后，讨论两种扩展即可。

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 110
#define R register
#define gc getchar
using namespace std;

int a[N]={0};
bool val[100]={1},f[N][3][3][2];

inline int rd(){
  int x=0; bool f=0; char c=gc();
  while(!isdigit(c)){if(c=='-')f=1;c=gc();}
  while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=gc();}
  return f?-x:x;
}

int main(){
  int t=rd();
  for(R int i=0;i<=35;++i)
    for(R int j=0;j<=25;++j)
      if(3*i+4*j<=100) val[3*i+4*j]=1;
  while(t--){
    memset(f,0,sizeof(f));
    f[0][0][0][0]=1;
    for(R int i=1;i<=100;++i) a[i]=rd();
    for(R int i=0;i<=99;++i)
      for(R int j=0;j<=2;++j)
        for(R int k=0;k<=2;++k){
          if(f[i][j][k][0])
            for(R int s=0;s<=2;++s){
              int num=a[i+1]-j-k-s;
              if(num>=0&&val[num]) f[i+1][k][s][0]=1;
              if(num-2>=0&&val[num-2]) f[i+1][k][s][1]=1;
            }
          if(f[i][j][k][1])
            for(R int s=0;s<=2;++s){
              int num=a[i+1]-j-k-s;
              if(num>=0&&val[num])f[i+1][k][s][1]=1;
            }
        }
    puts(f[100][0][0][1]?"Yes":"No");
  }
  return 0;
}

$[\ ZJOI\ 2006\ ]\ Mahjong$

\(Description\)

\(Solution\)

\(\text O(N\times 100^3)\)：

\(\Theta(N\times 100\times 3^3)\)：

猜你喜欢