几道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
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

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
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.csdn.net/can919/article/details/80154917
#include
using namespace std;
typedef long long ll;
const int maxn = 310;
const ll mod = 1e9+7;
ll a[maxn];
mapmp;
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(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);
}