CCPC 2015 I Mahjong hdu 5548

http://acm.hdu.edu.cn/showproblem.php?pid=5548

题意：给定n类麻将，每类最多四张，让你找出M张牌的胡的方案数（M≡2(mod3) ）。胡的条件的，这M张牌，可以分为一个对子+x个三条+y个顺子（3*x+3*y+2=M）。

 错误做法：dp[i][j][a][b][c]表示取到第i类牌，已经取了j张牌，i-2类还剩a张，i-1类还剩b张，c表示对子取或没取。这个dp的转移显而易见，但是在这个转移中会有重复，比如3 3 3这样的情况，既可以分为三个三条，也可以分为三个顺子，于是就重复计算了。这种做法的错误在于求的是到达结果的方案有多少种，而答案要求的是结果的状态有多少种。

做法：所谓的dp套dp。先dp（bfs？）出所有可能的状态集合。当我们用a,b,c(a表示取i-2类牌的数量，b取表示i-1类牌的数量，c表示对子取或没取，此处与上面的dp意义不同，上面表示的是剩余的牌数，而此处表示的是答案在这个位子取走的牌数还剩多少)表示一个状态的时候，那么在第i个位置取走k张牌是，这个[a][b][c]状态所能到达的状态集合应是等价的。所以我们只需知道有多少个状态集合出现过，并且每个状态集合在末尾取走k张牌时会进入到哪个集合时（一种自动机的感觉），就可以在这个上面做dp了。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
using namespace std;
#define mod 1000000007
int to[1111][5];
int flag[1111];
int tot;
struct node{
	long long stats;
	int label;
	node(){}
	node(const long long &stats,const int &label):stats(stats),label(label){}
};

bool operator<(const node &a,const node &b)
{
	return a.stats<b.stats;
}
set<node>st;
int getID(long long stats)
{
	set<node>::iterator it;
	it=st.find(node(stats,0));
	if(it==st.end()){
		st.insert(node(stats,tot++));
		return tot-1;
	}
	else return (*it).label;
}
void pre()
{
	tot=1;
	queue<long long>q;
	st.clear();
	long long endless=1<<25;
	st.insert(node(1,0));
	q.push(1);
	while(!q.empty())
	{
		long long d=q.front();
		q.pop();
		int nowId=getID(d);
		if(d&(1<<25))flag[nowId]=1;
		for(int k=0;k<=4;k++)
		{
			long long new_stats=0;
			for(int a=0;a<5;a++)
			{
				for(int b=0;b<5;b++)
				{
					for(int c=0;c<2;c++)
					{
						int sum=a+b*5+c*25;
						if((1ll<<sum)&d)
						{
							
							if(a>b||a>k||b>k)continue;
							int new_a,new_b,new_c;
							new_a=b-a;
							new_b=k-a;
							new_c=c;
							int new_sum=new_a+new_b*5+new_c*25;
							new_stats|=(1ll<<new_sum);
							if(new_b>=3){
								new_sum=new_a+(new_b-3)*5+new_c*25;
								new_stats|=(1ll<<new_sum);
							}
							if(new_c==0&&new_b>=2)
							{
								new_sum=new_a+(new_b-2)*5+25;
								new_stats|=(1ll<<new_sum);
							}
						}
					}
				}
			}
			if(st.find(node(new_stats,0))==st.end()){
				q.push(new_stats);
			}
			int toId=getID(new_stats);
			to[nowId][k]=toId;
		}
	}
}
long long ans[202][202];
long long dp[2][205][333];
void INIT()
{
	pre();
//	printf("%d\n",tot);
	int th=0;
	dp[th][0][0]=1;
	for(int i=0;i<=200;i++)
	{
		memset(dp[th^1],0,sizeof(dp[th^1]));
		for(int j=0;j<=200;j++)
		{
			for(int l=0;l<tot;l++)
			{
				if(dp[th][j][l]==0)continue;
				if(flag[l]){
					ans[i][j]+=dp[th][j][l];
					ans[i][j]%=mod;
				}
				for(int o=0;o<5;o++)
				{
					dp[th^1][j+o][to[l][o]]+=dp[th][j][l];
					dp[th^1][j+o][to[l][o]]%=mod;
				}
			}
		}
		th^=1;
	}
}
int main()
{
	INIT();
	int n,m;
	int T;
	scanf("%d",&T);
	int cas=0;
	while(T--)
	{
		scanf("%d%d",&n,&m);
		printf("Case #%d: %lld\n",++cas,ans[n][m]);
	}
}