[国家集训队] Crash 的文明世界

Posted 2021-01-31 asuldb

先写一个五十分的思路吧

首先这道题有一个弱化版

[POI2008]STA-Station

相当于(k=1)，于是就是一个非常简单的树形(dp)的(up and down)思想

但是我们现在要求的是这个柿子了

[sum_{j=1}^ndis(i,j)^k]

感觉这个东西很组合数学啊，感觉这个柿子像是天生为二项式定理准备的

我们还是考虑树形(dp)

在第一遍(up)的时候，我们设(dp[i][k])表示

[sum_{jin{i}}dis(i,j)^k]

(jin{i})表示(j)在(i)子树内部

于是我们考虑一下化这个柿子

到达(i)肯定要先达到(i)的一个儿子，于是就有

[dp[i][k]=sum_{fa[j]=i}sum_{tin{j}}(dis(t,j)+1)^k]

我们用二项式定理来将这个柿子展开

[dp[i][k]=sum_{fa[j]=i}sum_{tin{j}}sum_{r=0}^kC_{k}^{r}*dis(t,j)^r]

后面两个(sum)换一下位置

[dp[i][k]=sum_{fa[j]=i}sum_{r=0}^kC_{k}^{r}*sum_{tin{j}}dis(t,j)^r]

之后就会惊奇的发现(sum_{tin{j}}dis(t,j)^r)就是(dp[j][r])，于是现在就有了

[dp[i][k]=sum_{fa[j]=i}sum_{r=0}^kC_{k}^{r}*dp[j][r]]

这就是(up)的转移方程式，(down)的方程式也很好推

(down)的时候(dp[i][k])表示的不仅局限于(i)的子树内部了，而是整棵树了

到达(i)首先要到达(fa[i])，于是就有

[dp[i][k]+=sum_{j otin{i},jin{fa[i]}}(dis(fa[i],j)+1)^k]

[dp[i][k]+=sum_{j otin{i},jin{fa[i]}}sum_{r=0}^kC_{k}^r*dis(fa[i],j)^r]

我们的要求不就是(j)不能来自于(i)内部吗，于是我们大力容斥就好了

我们把来自于(i)子树内部的答案减掉，于是就有了一个可以更新的柿子了

现在就有了一个我们就可以转移了，复杂度大概是(O(nk^2))

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#define re register
#define maxn 50005
#define int long long
const int mod=10007; 
inline int read()
{
    char c=getchar();
    int x=0;
    while(c<‘0‘||c>‘9‘) c=getchar();
    while(c>=‘0‘&&c<=‘9‘)
        x=(x<<3)+(x<<1)+c-48,c=getchar();
    return x;
}
struct E
{
    int v,nxt;
}e[maxn<<1];
int head[maxn],deep[maxn];
int n,m,num;
long long dp[maxn][151];
long long now[151];
long long c[151][151];
void dfs(int x)
{
    dp[x][0]=1;
    for(re int i=head[x];i;i=e[i].nxt)
    if(!deep[e[i].v])
    {
        deep[e[i].v]=deep[x]+1;
        dfs(e[i].v);
        dp[x][0]+=dp[e[i].v][0];
        for(re int k=1;k<=m;k++)
            for(re int r=0;r<=k;r++)
                dp[x][k]=(dp[x][k]+c[k][r]*dp[e[i].v][r])%mod;
    }
}
void redfs(int x)
{
    for(re int i=head[x];i;i=e[i].nxt)
    if(deep[e[i].v]>deep[x])
    {
        memset(now,0,sizeof(now));
        for(re int k=0;k<=m;k++)
        {
            now[k]=dp[x][k];
            for(re int r=0;r<=k;r++)
                now[k]=(now[k]-dp[e[i].v][r]*c[k][r]+mod)%mod;
        }//先容斥，不能来自于e[i].v子树内部
        for(re int k=0;k<=m;k++)
            for(re int r=0;r<=k;r++)
                dp[e[i].v][k]=(dp[e[i].v][k]+c[k][r]*now[r])%mod;//用容斥之后的答案来更新
        redfs(e[i].v);
    }
}
inline void add_edge(int x,int y)
{
    e[++num].v=y;
    e[num].nxt=head[x];
    head[x]=num;
}
signed main()
{
    n=read(),m=read();
    int x,y;
    for(re int i=1;i<n;i++)
        x=read(),y=read(),add_edge(x,y),add_edge(y,x);
    c[0][0]=1;
    for(re int i=1;i<=m;i++) c[i][0]=c[i][i]=1;
    for(re int i=1;i<=m;i++)
        for(re int j=1;j<i;j++) c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod;
    deep[1]=1;
    dfs(1);
    redfs(1);
    for(re int i=1;i<=n;i++)
        printf("%lld
",(dp[i][m]%mod+mod)%mod);
    return 0;
}

这是一个要T的复杂度，但是已经有了(50)分的好成绩

点分治据说可以做到(O(nklogk))，但是不会

我们继续组合数做吧

我们发现求(x^k)可以理解为把(k)个物品放到(x)个互不相同的盒子里，允许有盒子空着不放的方案数

于是我们可以写成(x^k=sum_{i=1}^kS(k,i)*C_{x}^i*i!)

其中(S(k,i))是第二类斯特林数，表示的是将(k)个球分到(i)个盒子里，这(i)个盒子没有差别，而且没有盒子是空的的方案数

(C_{x}^i*i!)其实就是排列数了，就相当于我们给(i)个盒子强行制造了差别

于是这个柿子可以理解为(i)枚举的是当前有几个盒子是有球的，之后通过加法原理合并了答案

其实我一开始觉得这里的(sum)的上标应该写(x)，好像也只有写(x)才满足组合的意义，之后发现自己非常naive

1. 当(k>x)的时候显然是没有什么问题的了，因为(inom{x}{i})在(x>i)的时候取0，于是没有什么影响

2. 当(k<x)的时候，如果上标取到比(k)大的数了，那么也会导致(S(k,i))变成(0)，于是写成(k)就可以了，在数值上没有什么影响

之后我们继续化柿子

[ans[t]=sum_{j=1}^{n}dis(t,j)^k]

[=sum_{j=1}^{n}sum_{i=1}^kS(k,i)*inom{dis(t,j)}{i}*i!]

[=sum_{i=1}^{k}S(k,i)*i!*sum_{j=1}^ninom{dis(t,j)}{i}]

那么我们现在只需要求出(sum_{j=1}^ninom{dis(t,j)}{i})就好了

我们都知道组合数有一个非常好的转移的方式就是(inom{n}{m}=inom{n-1}{m-1}+inom{n-1}{m})

于是

[sum_{j=1}^ninom{dis(t,j)}{i}=sum_{j=1}^ninom{dis(t,j)-1}{i-1}+sum_{j=1}^ninom{dis(t,j)-1}{i}]

现在是不是又可以用树形dp来转移了，因为到达(t)这个点还是要先到达(t)的儿子或者是父亲

于是我们设(dp[x][k]=sum_{jin{x}}inom{dis(x,i)}{k})

于是在(up)里的方程式就是

[dp[x][k]=sum_{fa[j]=i}dp[j][k]+dp[j][k-1]]

(down)里我们还是要先容斥一下，方程和(up)类似

代码

#include<iostream>
#include<cstring>
#include<cstdio>
#define re register
#define maxn 50005
#define LL long long
const LL mod=10007;
inline int read()
{
    char c=getchar();
    int x=0;
    while(c<‘0‘||c>‘9‘) c=getchar();
    while(c>=‘0‘&&c<=‘9‘)
        x=(x<<3)+(x<<1)+c-48,c=getchar();
    return x;
}
struct node
{
    int v,nxt;
}e[maxn<<1];
int head[maxn],deep[maxn];
LL dp[maxn][151],fac[151],s[151][151];
LL now[151];
int n,m,num;
inline void add_edge(int x,int y)
{
    e[++num].v=y;
    e[num].nxt=head[x];
    head[x]=num;
}
void dfs(int x)
{
    dp[x][0]=1;
    for(re int i=head[x];i;i=e[i].nxt)
    if(!deep[e[i].v])
    {
        deep[e[i].v]=deep[x]+1;
        dfs(e[i].v);
        dp[x][0]+=dp[e[i].v][0];
        for(re int j=1;j<=m;j++)
            dp[x][j]=(dp[x][j]+dp[e[i].v][j-1]+dp[e[i].v][j])%mod;
    }
}
void redfs(int x)
{
    for(re int i=head[x];i;i=e[i].nxt)
    if(deep[e[i].v]>deep[x])
    {
        memset(now,0,sizeof(now));
        now[0]=dp[x][0]-dp[e[i].v][0];
        for(re int j=1;j<=m;j++)
            now[j]=(dp[x][j]-dp[e[i].v][j]-dp[e[i].v][j-1]+mod)%mod;
            //依旧是先容斥一遍
        dp[e[i].v][0]+=now[0];
        for(re int j=1;j<=m;j++)
            dp[e[i].v][j]=(dp[e[i].v][j]+now[j]+now[j-1])%mod;
        redfs(e[i].v);
    }
}
int main()
{
    n=read(),m=read();
    int x,y;
    for(re int i=1;i<n;i++)
        x=read(),y=read(),add_edge(x,y),add_edge(y,x);
    s[0][0]=1;
    for(re int i=1;i<=m;i++)
        s[i][1]=s[i][i]=1;
    for(re int i=1;i<=m;i++)
        for(re int j=1;j<i;j++)
            s[i][j]=(s[i-1][j-1]+s[i-1][j]*j)%mod;//预处理第二类斯特林数
    fac[0]=1;
    for(re int i=1;i<=m;i++)
        fac[i]=(fac[i-1]*i)%mod;//预处理阶乘
    deep[1]=1;
    dfs(1);
    redfs(1);
    for(re int i=1;i<=n;i++)
        for(re int j=1;j<=m;j++)
            dp[i][j]=(dp[i][j]%mod+mod)%mod;
    for(re int i=1;i<=n;i++)
    {
        LL ans=0;
        for(re int j=1;j<=m;j++)
            ans=(ans+s[m][j]*fac[j]%mod*dp[i][j])%mod;
        printf("%lld
",ans);//统计答案
    }
    return 0;
}