先寫一個五十分的思路吧

首先這道題有一個弱化版

[POI2008]STA-Station

相當於\(k=1\)，於是就是一個非常簡單的樹形\(dp\)的\(up\ \ and\ \ down\)思想

但是我們現在要求的是這個柿子了

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

感覺這個東西很組合數學啊，感覺這個柿子像是天生為二項式定理準備的

我們還是考慮樹形\(dp\)

在第一遍\(up\)的時候，我們設\(dp[i][k]\)表示

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

\(j\in{i}\)表示\(j\)在\(i\)子樹內部

於是我們考慮一下化這個柿子

到達\(i\)

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

我們用二項式定理來將這個柿子展開

\[dp[i][k]=\sum_{fa[j]=i}\sum_{t\in{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_{t\in{j}}dis(t,j)^r\]

之後就會驚奇的發現\(\sum_{t\in{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\notin{i},j\in{fa[i]}}(dis(fa[i],j)+1)^k\]

\[dp[i][k]+=\sum_{j\notin{i},j\in{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\n",(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\)的時候顯然是沒有什麽問題的了，因為\(\binom{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)*\binom{dis(t,j)}{i}*i!\]

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

那麽我們現在只需要求出\(\sum_{j=1}^n\binom{dis(t,j)}{i}\)就好了

我們都知道組合數有一個非常好的轉移的方式就是\(\binom{n}{m}=\binom{n-1}{m-1}+\binom{n-1}{m}\)

於是

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

現在是不是又可以用樹形dp來轉移了，因為到達\(t\)這個點還是要先到達\(t\)的兒子或者是父親

於是我們設\(dp[x][k]=\sum_{j\in{x}}\binom{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\n",ans);//統計答案
    }
    return 0;
}

【[國家集訓隊] Crash 的文明世界】