[CodeForces-708E]Student's Camp

题目大意：
　　一个n*m的墙，被吹k天风，每块靠边的砖都有p的概率被吹掉。
　　如果上下两行没有直接相连的地方，我们则认为这一堵墙已经倒塌。
　　问最后墙不倒塌的概率（模意义）。

思路：
　　动态规划。
　　用f[i][j][k]表示到了第i层，只剩下j~k的砖头并且不倒塌的概率。
　　则f[i][j][k]=sum{f[i-1][l][r]|[l,r]与[j,k]有交集}*这一层只剩[l,r]的概率。
　　概率可以O(n)预处理，接下来要枚举i,j,k,l,r，所以是O(m^4n)的。
　　接下来考虑预处理sum{f[i-1][l][r]|[l,r]与[j,k]有交集}。
　　显然有交集的概率=总概率-没有交集的概率=总概率-r<i的概率-j<l的概率。
　　而这些概率都可以一边转移一边推。
　　这样转移的时候就不需要考虑具体的l,r，是O(m^2n)的。
　　数组1500^3还会爆，考虑滚动数组，勉强开下，反正还是TLE。
　　正解是一个很神奇的O(mn)算法。（并不是很懂）
　　考虑用f[i][k]表示前面的f[i][1][k]~f[i][k][k]的和。
　　然后预处理所有关于j的前缀和。
　　然后递推式就只与i,k有关了。

#include<cstdio>
#include<cctype>
typedef long long int64;
inline int getint() {
    register char ch;
    while(!isdigit(ch=getchar()));
    register int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int mod=1e9+7;
const int N=1501,M=1501,K=100001;
void exgcd(const int &a,const int &b,int &x,int &y) {
    if(!b) {
        x=1;
        y=0;
        return;
    }
    exgcd(b,a%b,y,x);
    y-=a/b*x;
}
inline int inv(const int64 &x) {
    int tmp,ret;
    exgcd(x,mod,ret,tmp);
    return (ret+mod)%mod;
}
int f[2][M];
int p[K],q[K];
int fact[K],tcaf[K];
int k;
inline int calc(const int &x) {
    return (int64)fact[k]*tcaf[k-x]%mod*tcaf[x]%mod*p[x]%mod*q[k-x]%mod;
}
int main() {
    int n=getint(),m=getint();
    int a=getint(),b=getint();
    k=getint();
    fact[0]=1;
    for(register int i=1;i<=k;i++) {
        fact[i]=(int64)fact[i-1]*i%mod;
    }
    tcaf[k]=inv(fact[k]);
    for(register int i=k-1;~i;i--) {
        tcaf[i]=(int64)tcaf[i+1]*(i+1)%mod;
    }
    p[0]=q[0]=1;
    p[1]=q[1]=inv(b);
    p[1]=(int64)p[1]*a%mod;
    q[1]=(int64)q[1]*(b-a)%mod; 
    for(register int i=2;i<=k;i++) {
        p[i]=(int64)p[i-1]*p[1]%mod;
        q[i]=(int64)q[i-1]*q[1]%mod;
    }
    f[0][m]=1;
    for(register int i=1;i<=n;i++) {
        int s1=0,s2=0;
        for(register int j=0;j<=m;j++) {
            f[i&1][j]=((int64)s1*(f[!(i&1)][m]-f[!(i&1)][m-j])-s2)%mod*calc(m-j)%mod;
            s1=(s1+calc(j))%mod;
            s2=(s2+(int64)f[!(i&1)][j]*calc(j))%mod;
        }
        for(register int j=1;j<=m;j++) {
            f[i&1][j]=(f[i&1][j]+f[i&1][j-1])%mod;
        }
    }
    printf("%d\n",(f[n&1][m]+mod)%mod);
    return 0;
}