几道dp

http://codeforces.com/problemset/problem/553/A

题意：一串球，每种颜色的球有ci个，并且根据安排，前一种颜色的最后一个球需要放在后一种球最后一个前面，求方案数。

// *1700
// dp[i][j]表示前i种球恰好在前j个位置draw完的方案数，那么第i种球的最后一个定在j位置上。
// 转移方程的dp[i][j] = sum(dp[i-1][k]*第 i种球放置的方案数f(i,j)) (其中k<j)
// 第i种球最后一个已经固定，假设剩下m个i球没有固定，假设前面还有n个空位未放球，则显然f(i,j) = n!/(m!*(n-m)!)
// 其次对于sum()函数我们每行dp完求一下前缀和即可解决
// 可以转换为1维dp：dp[i]表示前i种球放好的方案数，转移dp[i] = dp[i-1] * C(前i种球总数-1，第i种球个数-1)
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;
const int maxn = 1e6+100;
int c[1005];
int sum[1005];
ll dp[1005][1005];
ll inv[maxn],fac[maxn],invf[maxn];   //inv[i]为i的逆元，fac[i]为阶乘i!，invf[i]为阶乘i!的逆元
void init()
{
    inv[1]=1;  
    for (int i=2;i<maxn;i++)  
        inv[i]=((mod-mod/i)*inv[mod%i])%mod; 
    fac[0] = 1; 
    for(int i = 1;i<maxn;i++)
        fac[i] = (fac[i-1] * (ll)i)%mod;
    invf[0] = 1;
    for(int i = 1;i<maxn;i++)
        invf[i] = (invf[i-1]*inv[i])%mod;
}
int main()
{
    init();
    int k;
    scanf("%d",&k);
    sum[0] = 0;
    for(int i = 1;i<=k;i++)scanf("%d",&c[i]),sum[i] =sum[i-1] +  c[i];
    memset(dp,0,sizeof(dp));
    for(int i = 0;i<=sum[k];i++)dp[0][i] = 1;
    for(int i = 1;i<=k;i++)
    {
        for(int j = sum[i];j<=sum[k] - (k-i);j++)
        {
            dp[i][j] = (((dp[i-1][j-1] * fac[j-sum[i-1]-1])%mod * invf[c[i]-1])%mod * invf[j - sum[i-1] - c[i]])%mod;
        }
        for(int j = sum[i];j<=sum[k];j++)
        {
            dp[i][j] = (dp[i][j] + dp[i][j-1])%mod;
        }
    }
    printf("%I64d\n",dp[k][sum[k]]);
}

http://codeforces.com/problemset/problem/489/F

题意：一个n*m的矩阵，每行每列都只有2个1，其余为0，给出部分行，求出剩下的方案数。

// *2200
// dp[k][i][j]表示第k层后有i个列缺1个1，有j个列缺2个1的方案数,转移有三种方案数
// 1.dp[k+1][i-2][j] += dp[k][i][j] * (i * (i-1) / 2)  (i>=2)
// 2.dp[k+1][i+2][j-2] += dp[k][i][j] *(j *(j-1) / 2)  (j>=2)
// 3.dp[k+1][i][j-1] += dp[k][i][j] * (i*j)            (i>=1 && j>= 1)
// 层数滚动防止爆内存，对于dp[k][i][j] == 0的情况不做转移，防止超时
// 也可以变成二维数组加速就不会有爆内存和超时的问题（利用i和j之间的关系，k行之后需要1的总个数确定，再确定其中一个就可以确定另一个）
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 505;
ll mod;
int num[maxn];
ll dp[2][maxn][maxn]; //dp[k][i][j]到第k层后有i个列缺1个1，有j个列缺2个1的方案数
int main()
{
    
    memset(num,0,sizeof(num));
    int n,m;
    scanf("%d%d%I64d",&n,&m,&mod);
    char s[maxn];
    for(int i = 1;i<=m;i++)
    {
        scanf("%s",s+1);
        for(int j = 1;j<=n;j++)
        {
            if(s[j]=='1')num[j]++;
        }
    }
    int cnt1 = 0,cnt2 = 0;
    for(int i = 1;i<=n;i++)
    {
        if(num[i]==0)cnt2++;
        if(num[i]==1)cnt1++;
    }
    memset(dp,0,sizeof(dp));
    dp[m&1][cnt1][cnt2] = 1;
    for(int k = m;k<=n-1;k++)
    {
        for(int i = 0;i<=n;i++)
        {
            for(int j = 0;j<=n;j++)
            {
                if(!dp[k&1][i][j])continue;
                if(i>=2)
                {
                    ll c = (i * (i-1)/2)%mod;
                    dp[(k+1)&1][i-2][j] = (dp[(k+1)&1][i-2][j] + (dp[k&1][i][j] * c)%mod)%mod;
                }
                if(j>=2)
                {
                    ll c = (j * (j-1)/2)%mod;
                    dp[(k+1)&1][i+2][j-2] = (dp[(k+1)&1][i+2][j-2] + (dp[k&1][i][j] * c)%mod)%mod;
                }
                if(i>=1&&j>=1)
                {
                    ll c = (i*j)%mod;
                    dp[(k+1)&1][i][j-1] = (dp[(k+1)&1][i][j-1] + (dp[k&1][i][j] * c)%mod)%mod;
                }
            }
        }
    }
    printf("%I64d\n",dp[n&1][0][0]);
}

http://codeforces.com/problemset/problem/840/C

题意：将一个长为n的数组安排成相邻数相乘不为完全平凡数的方案数。（每个数实质id不同）

// *2600
// 注意：此题每个数的id都是不同的
// 容斥及dp
// 1.首先想到：a*b为完全平方数、b*c为完全平方数，则a*c也为完全平方数
// 因为每个数的每个质因子数或为奇数或为偶数，只要能够契合为全偶数就能组成完全平方数
// 所以可以将原数组中所有的数去掉完全平方因子，原问题转换为数组排列，使得相邻两个数相乘不能组成完全平方数的方案数
// 也可以通过并查集来转换，稍繁琐一些。
// 2.解决这个问题需要用到容斥原理，设fx表示组成的数组中至少有x对相邻的数能组成完全平方数。
// 那么 ans = f0 - f1 + f2 - f2 + ... + (-1)^x*fx
// 3.如何来求解fx呢，用到dp
// dp[i][j]表示前i种数分成j块且块内的数相等的方案数（块间未排序），那么排好之后就最多有j-1对相邻的数不相等（原题中不能组成完全平方数）
// 也即至少有(n-1)-(j-1)=n-j对相邻的数能组成完全平方数
// 所以得到 f(n-j) = dp[cnt][j] * j! (cnt为数的种数，j!使块间排序)
// 4.dp如何转移：
// dp[i][j] = sum(dp[i-1][j-k]*C(ni-1,k-1)*ni!/!) (1<=k<=j-i+1&&k<=ni) ni为第i种数的个数
// 意思是利用隔板法将第i种数分为k块（块内排序，块间不排序）加入到前面的方案中
// 详见：https://blog.youkuaiyun.com/can919/article/details/80154917
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 310;
const ll mod = 1e9+7;
ll a[maxn];
map<int,int>mp;
int num[maxn];
ll dp[maxn][maxn];
ll inv[maxn],fac[maxn],invf[maxn];   //inv[i]为i的逆元，fac[i]为阶乘i!，invf[i]为阶乘i!的逆元
void init()
{
    inv[1]=1;  
    for (int i=2;i<maxn;i++)  
        inv[i]=((mod-mod/i)*inv[mod%i])%mod; 
    fac[0] = 1; 
    for(int i = 1;i<maxn;i++)
        fac[i] = (fac[i-1] * (ll)i)%mod;
    invf[0] = 1;
    for(int i = 1;i<maxn;i++)
        invf[i] = (invf[i-1]*inv[i])%mod;
}
int main()
{
    init();
    mp.clear();
    int n;
    int ncnt = 0;
    memset(num,0,sizeof(num));
    scanf("%d",&n);
    // bool ok = true;
    for(int i = 1;i<=n;i++)
    {
        scanf("%I64d",&a[i]);
        ll tmp = a[i];
        for(int j = 2;1ll*j*j<=a[i];j++)
        {
            while(tmp %(j*(ll)j)==0)tmp /= (j * (ll)j);
        }
        if(!mp[tmp])mp[tmp] = ++ncnt;
        num[mp[tmp]]++;
        // if(num[mp[tmp]]>(n+1)/2)ok = false;
    }
    // if(!ok)
    // {
    //     printf("0\n");
    //     return 0;
    // }
    memset(dp,0,sizeof(dp));
    dp[0][0] = 1;
    int sum = 0;
    for(int i = 1;i<=ncnt;i++)
    {
        sum += num[i];
        for(int j = i;j<=sum;j++)
        {
            for(int k = 1;j-k>=i-1&&num[i]>=k;k++)
            {
                ll c = ((fac[num[i]-1] * invf[k-1])%mod * invf[num[i]-k])%mod;
                dp[i][j] = (dp[i][j] + (((dp[i-1][j-k] * c)%mod * fac[num[i]])%mod * invf[k])%mod)%mod;
            }
        }
    }
    ll ans = 0;
    bool flag = true;
    for(int i = n;i>=ncnt;i--)
    {
        ans = (ans + (((flag?1:-1) * dp[ncnt][i])%mod * fac[i])%mod + mod)%mod;
        flag = !flag;
    }
    printf("%I64d\n",ans);
}