【转】ural 1476

转自 http://www.nocow.cn/index.php/URAL/1476

设 F [ i , j ] 为前i列计算完成且第i列一共有j个0时所有的合法方案数。

那么首先 F [ 1 , i ] = Combine [ N , i ]

那么每次可以枚举0后面接0个数pA，1后面接0个数pB

那么从 F [ i , j ] 就可以推出 F [ i + 1 , pA + pB ] ,

中间只需要满足 j - pA <= K 即可。（一共j个0，后面接了j-pA个1，所以“01”的个数就是j - pA ）

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define zero(x) (fabs(x)<eps)
#define pi acos(-1.0)
#define f1 first
#define f2 second
const int inf=0x3f3f3f3f;
typedef long long LL;
using namespace std;
#define MS(x, y) memset(x, y, sizeof(x))
#define FOR(i, x, y) for(int i=x; i<=y; i++)
#define rFOR(i, x, y) for(int i=x; i>=y; i--)
using namespace std;
const int maxn = 600;
struct bigint
{
    int s[maxn];

    bigint() {MS(s, 0);}
    bigint(int num) {*this = num;}
    bigint(const char* num){*this = num;}

    bigint operator = (const char* num) 
    {
        MS(s, 0);
        if(num[0] == '-')
        {
            num = num + 1;
            s[0] = -1;
        }
        else s[0] = 1;
        while(num[0] == '0') num = num + 1;
        s[0] = s[0] * strlen(num);
        int len = abs(s[0]);
        FOR(i, 1, len) s[i] = num[len - i] - 48;
        return *this;
    }
    bigint operator = (int num)         //鏁存暟璧嬪€�
    {
        char s[maxn];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }

    string str() const                      
    {
        string res = "";
        FOR(i, 1, abs(s[0])) res = (char)(s[i] + 48) + res;
        if(res == "") return res = "0";
        if(s[0] < 0) res = '-' + res;
        return res;
    }
   
    bool operator < (const bigint& b) const
    {
        if(s[0] != b.s[0]) return s[0] < b.s[0];
        int len = abs(s[0]);
        rFOR(i, len, 1)
        if(s[i] != b.s[i])
            return (s[i] < b.s[i]) ^ (s[0] < 0);
        return false;
    }
    bool operator > (const bigint& b) const{return b < *this;}
    bool operator <= (const bigint& b) const{return !(b < *this);}
    bool operator >= (const bigint& b) const{return !(*this < b);}
    bool operator != (const bigint& b) const{return b < *this || *this < b;}
    bool operator == (const bigint& b) const{return !(b < *this) && !(*this < b);}

    friend bigint abs(bigint b)
    {
        b.s[0] = abs(b.s[0]);
        return b;
    }
    friend bigint _add(const bigint& a, const bigint& b)
    {
        bigint c;
        c.s[0] = max(a.s[0], b.s[0]);
        FOR(i, 1, c.s[0]) c.s[i] = a.s[i] + b.s[i];
        FOR(i, 1, c.s[0])
        if(c.s[i] >= 10)
        {
            c.s[i+1]++;
            c.s[i]-=10;
        }
        if(c.s[c.s[0]+1]) ++c.s[0];
        return c;
    }
    friend bigint _sub(const bigint& a, const bigint& b)
    {
        bigint c;
        c.s[0] = a.s[0];
        FOR(i, 1, c.s[0]) c.s[i] = a.s[i] - b.s[i];
        FOR(i, 1, c.s[0])
        if(c.s[i] < 0)
        {
            c.s[i+1]--;
            c.s[i] += 10;
        }
        while(!c.s[c.s[0]] && c.s[0]) --c.s[0];
        return c;
    }
    bigint operator + (const bigint& b) const
    {
        if(s[0] >= 0 && b.s[0] >= 0) return _add(*this, b);
        if(b.s[0] < 0) return *this - abs(b);
        if(s[0] < 0) return b - abs(*this);
    }
    bigint operator - (const bigint& b) const
    {
        if(s[0] >= 0 && b.s[0] >= 0)
        {
            bigint c;
            if(*this >= b) return _sub(*this, b);
            c = _sub(b, *this);
            c.s[0] = -c.s[0];
            return c;
        }
        if(b.s[0] < 0) return *this + abs(b);
        if(s[0] < 0)
        {
            bigint c;
            c = abs(*this) + b;
            c.s[0] = -c.s[0];
            return c;
        }
    }
    bigint operator * (const bigint& b) const
    {
        bigint c;
        c.s[0] = abs(s[0]) + abs(b.s[0]);
        FOR(i, 1, abs(s[0]))
        FOR(j, 1, abs(b.s[0]))
            c.s[i + j - 1] += s[i] * b.s[j];
        FOR(i, 1, c.s[0])
        {
            c.s[i+1] += c.s[i] / 10;
            c.s[i] %= 10;
        }
        while(!c.s[c.s[0]] && c.s[0]) --c.s[0];
        if((s[0] > 0) != (b.s[0] > 0)) c.s[0] = -c.s[0];
        return c;
    }
    bigint operator / (const bigint& _b) const
    {
        bigint c, t;
        bigint b = abs(_b);
        c.s[0] = abs(s[0]);
        rFOR(i, c.s[0], 1)
        {
            rFOR(j, t.s[0], 1) t.s[j + 1] = t.s[j];
            t.s[1] = s[i];
            if (t.s[t.s[0]+1])t.s[0]++;

            while(t >= b)
            {
                ++c.s[i];
                t -= b;
            }
        }
        while(!c.s[c.s[0]] && c.s[0]) --c.s[0];
        if((s[0] > 0) != (b.s[0] > 0)) c.s[0] = -c.s[0];
        return c;
    }
    bigint operator % (const bigint& _b) const
    {
        bigint c, t;
        bigint b = abs(_b);
        rFOR(i, abs(s[0]), 1)
        {
            rFOR(j, t.s[0], 1) t.s[j + 1] = t.s[j];
            t.s[1] = s[i];
            if (t.s[t.s[0]+1])t.s[0]++;

            while(t >= b) t -= b;
        }
        if((s[0] < 0)) t.s[0] = -t.s[0];
        return t;
    }

    bigint operator += (const bigint& b) {*this = *this + b;return *this;}
    bigint operator -= (const bigint& b) {*this = *this - b;return *this;}
    bigint operator *= (const bigint& b) {*this = *this * b;return *this;}
    bigint operator /= (const bigint& b) {*this = *this / b;return *this;}
    bigint operator %= (const bigint& b) {*this = *this % b;return *this;}

    friend bigint operator + (int& a, const bigint& b){return (bigint)a + b;}
    friend bigint operator - (int& a, const bigint& b){return (bigint)a - b;}
    friend bigint operator * (int& a, const bigint& b){return (bigint)a * b;}
    friend bigint operator / (int& a, const bigint& b){return (bigint)a / b;}
    friend bigint operator % (int& a, const bigint& b){return (bigint)a % b;}

    friend bigint operator <  (int& a, const bigint& b){return (bigint)a < b;}
    friend bigint operator <= (int& a, const bigint& b){return (bigint)a <=b;}
    friend bigint operator >  (int& a, const bigint& b){return (bigint)a > b;}
    friend bigint operator >= (int& a, const bigint& b){return (bigint)a >=b;}
    friend bigint operator == (int& a, const bigint& b){return (bigint)a ==b;}
    friend bigint operator != (int& a, const bigint& b){return (bigint)a !=b;}
};
istream& operator >> (istream &in, bigint& x)
{
    string s;
    in >> s;
    x = s.c_str();
    return in;
}
ostream& operator << (ostream &out, const bigint& x)
{
    out << x.str();
    return out;
}

#define N 41

bigint dp[N][N],c[N][N],t[N][N];
int n,m,K;
void doit()
{
    for (int i=0;i<=n;i++)
        dp[0][i]=c[n][i];
    for (int i=1;i<m;i++)
    for (int j=0;j<=n;j++)
        dp[i][j]=0;
    for (int i=0;i<m-1;i++)
    for (int j=0;j<=n;j++)
        if (dp[i][j]>0)
        for (int u=0;u<=n;u++)
            dp[i+1][u]+=dp[i][j]*t[u][j];

    bigint ans=0;
    for (int i=0;i<=n;i++)
        ans+=dp[m-1][i];
    cout<<ans<<endl;
}
void PRE()
{
    for (int i=0;i<=n;i++)
       c[i][0]=1;
    for (int i=0;i<=n;i++)
       for (int j=1;j<=i;j++)
            c[i][j]=c[i-1][j-1]+c[i-1][j];


    for (int i=0;i<=n;i++)
    for (int j=0;j<=n;j++)
        t[i][j]=0;
    for (int j=0;j<=n;j++)
    for (int k=0;k<=K;k++)
                {
                    if (k>j) break;
                    for (int z=0;z<=n;z++)
                        {   if (z>n-j) break;
                            t[n-k-z][j]+=c[j][k]*c[n-j][z];
                        }
                }
}
int main()
{
    while (scanf("%d%d%d",&n,&m,&K)!=EOF) {PRE();doit();}
}

具体 F [ i , j ] * Combine [ j , pA ] * Combine [ N - j , pB ] ---> F [ i + 1 , pA + pB ]

这样做是 O ( N ^ 4 )的，还要加上高精度 * 高精度的复杂度，最大数据要20多s。




这样可以做个优化，我们发现，每次从某一列的 j 状态转移到 下一列的pA + pB状态。

中间唯一变化的就是 F [ i , j ] 的值，中间过程中 类似“Combine [ j , pA ] * Combine [ N - j , pB ]”的式子

其实是一样的。 所以可以设 G [ j , K ] 为从j状态转移到k状态需要乘上的系数，做这个预处理是O(N^3)的，然后通过G数组

DP就可以降为O(N^3)了。