BZOJ 1072 [SCOI2007]排列perm (状态压缩+dp+同余定理)

1072: [SCOI2007]排列perm

Time Limit: 10 Sec   Memory Limit: 128 MB
Submit: 2537   Solved: 1583
[ Submit][ Status][ Discuss]

Description

　　给一个数字串s和正整数d, 统计s有多少种不同的排列能被d整除（可以有前导0）。例如123434有90种排列能
被2整除，其中末位为2的有30种，末位为4的有60种。

Input

　　输入第一行是一个整数T，表示测试数据的个数，以下每行一组s和d，中间用空格隔开。s保证只包含数字0, 1
, 2, 3, 4, 5, 6, 7, 8, 9.

Output

　　每个数据仅一行，表示能被d整除的排列的个数。

Sample Input

7
000 1
001 1
1234567890 1
123434 2
1234 7
12345 17
12345678 29

Sample Output

1
3
3628800
90
3
6
1398

HINT

在前三个例子中，排列分别有1, 3, 3628800种，它们都是1的倍数。

【限制】

100%的数据满足：s的长度不超过10, 1<=d<=1000, 1<=T<=15

BZOJ的题解都这尿性，千篇一律，感觉就是一个人写了之后其他人都这么写，对于我这种基础差的人简直就是煎熬，也许这种题很简单，哎。此题有暴力解法，也就不必再提，

此题首先要用到同余定理，就是一个大数模除一个数的余数等于这个大数每一位的数模除这个数的结果，知道这个定理之后，下面的状态压缩DP才有理论依据来做。首先，为什么要状态压缩？s的长度不超过10，也就是一个很简短的字符串，除了暴力枚举全排列，可以用状压来表示字符串的数字是否出现，出现为1，否则为1。此时可以枚举一个数，然后第二层循环枚举另一个数，让这两个数的与运算，当这两个数的与运算为0时，说明这两个数每一位的值都不一样，这样可以表示为每一位都是1，每一位都有用到。然后费尽波折得到递推公式：dp[i|(1<<(k-1))][j*10+ans[k])%d]+=dp[i][j].

此递推式就有用到同余定理，然后看到的博客没有一个说到的，递推式要满足i&(1<<(k-1))==0，因为要保证每一位都要用到。第一维的二进制代表当前串用了哪几位，第二维代表此时的余数是几。这样i从0到2^len，len代表字符串长度，k从0枚举到d-1.也就是余数最大为d-1.枚举j从1到len。首先第一维可以代表每一种状态，第二维枚举余数则是必然的。至于第一维的原理，多写几组示例就容易发现。

然后得到dp[1<<(len-1)][0]，此时并不是正确答案啊，因为若是有重复数字，他会重复计算，比如001，会出现两次010，也就是多出现了重复数字的阶乘倍，所以把组合数打个表，最后判断一下，出去阶乘就行了。

这个题对我来说难度还是有点大，毕竟菜，吐槽别人的题解，自己说的也不是很清楚。哎，等状压DP搞熟再回来更新。

代码实现（状压版）：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<cstdio>
#define ll long long
#define mset(a,x) memset(a,x,sizeof(a))

using namespace std;
const double PI=acos(-1);
const int inf=0x3f3f3f3f;
const double esp=1e-6;
const int maxn=2e5+5;
const int mod=1e9+7;
int dir[4][2]={0,1,1,0,0,-1,-1,0};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
ll inv(ll b){if(b==1)return 1; return (mod-mod/b)*inv(mod%b)%mod;}
ll fpow(ll n,ll k){ll r=1;for(;k;k>>=1){if(k&1)r=r*n%mod;n=n*n%mod;}return r;}
int dp[1<<10][1100],d,len,ans[15],visit[15];
char map[15]; 
int c[]={0,1,2,6,24,120,720,5040,40320,362880,3628800};   //组合数提前打表

void solve()
{
	int i,j,k;
	for(i=0;i<(1<<len);i++)
	{
		for(k=0;k<d;k++)
		{
			if(dp[i][k])
			{
				for(j=1;j<=len;j++)
				{
					if((i&(1<<(j-1)))==0)
                    {
                        dp[(i|(1<<(j-1)))][(k*10+ans[j])%d]+=dp[i][k];
                    }
				}
			}
		}
	}
}

int main()
{
	int t,n,i,j,k;
	scanf("%d",&t);
	getchar();
	while(t--)
	{
		mset(dp,0);
		mset(visit,0);
		cin>>map>>d;
		len=strlen(map);
		for(i=0;i<len;i++)
		{
			ans[i+1]=map[i]-'0';
			visit[ans[i+1]]++;
		}
		
		dp[0][0]=1;
		solve();
		int sum=dp[(1<<len)-1][0];
		
		for(i=0;i<10;i++)
		{
			if(visit[i])
			sum/=c[visit[i]];
		}
		cout<<sum<<endl;
	}
	return 0;
}

代码实现（暴力版）：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<cstdio>
#define ll long long
#define mset(a,x) memset(a,x,sizeof(a))

using namespace std;
const double PI=acos(-1);
const int inf=0x3f3f3f3f;
const double esp=1e-6;
const int maxn=2e5+5;
const int mod=1e9+7;
int dir[4][2]={0,1,1,0,0,-1,-1,0};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
ll inv(ll b){if(b==1)return 1; return (mod-mod/b)*inv(mod%b)%mod;}
ll fpow(ll n,ll k){ll r=1;for(;k;k>>=1){if(k&1)r=r*n%mod;n=n*n%mod;}return r;}

int main()
{
	string map;
	int t,ans[10005],i,j,k,d;
	cin>>t;
	while(t--)
	{
		cin>>map>>d;
		for(i=1;i<=map.size();i++)
		ans[i]=map[i-1]-'0';
		
		sort(ans+1,ans+1+map.size());
		ll sum=0;
		do{  
            ll temp=0;  
            for(i=1;i<=map.size();i++)  
            temp=temp*(ll)10+(ll)ans[i];  
            if(temp%d==0)  
            sum++; 
        }while(next_permutation(ans+1,ans+1+map.size())); 
        cout<<sum<<endl;
	}
	return 0;
}