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

先写一个五十分的思路吧

首先这道题有一个弱化版

[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\)肯定要先达到\(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;
}

原文地址:https://www.cnblogs.com/asuldb/p/10205776.html

时间: 2024-10-12 02:19:19

【[国家集训队] Crash 的文明世界】的相关文章

P4827 [国家集训队] Crash 的文明世界(第二类斯特林数+树形dp)

传送门 对于点\(u\),所求为\[\sum_{i=1}^ndis(i,u)^k\] 把后面那堆东西化成第二类斯特林数,有\[\sum_{i=1}^n\sum_{j=0}^kS(k,j)\times j!\times{dis(i,u)\choose j}\] \[\sum_{j=1}^nS(k,j)\times j!\sum_{i=0}^k{dis(i,u)\choose j}\] 于是对于每个点只要维护好\(\sum_{i=0}^k{dis(i,u)\choose j}\)就好了 因为\({n

bzoj 2159: Crash 的文明世界

2159: Crash 的文明世界 Time Limit: 10 Sec  Memory Limit: 259 MBSubmit: 478  Solved: 233[Submit][Status][Discuss] Description Crash 小朋友最近迷上了一款游戏——文明5(Civilization V).在这个游戏中,玩家可以建立和发展自己的国家,通过外交和别的国家交流,或是通过战争征服别的国家.现在Crash 已经拥有了一个N 个城市的国家,这些城市之间通过道路相连.由于建设道路

【bzoj 2159】Crash 的文明世界

Description Crash小朋友最近迷上了一款游戏——文明5(Civilization V).在这个游戏中,玩家可以建立和发展自己的国家,通过外交和别的国家交流,或是通过战争征服别的国家.现在Crash已经拥有了一个N个城市的国家,这些城市之间通过道路相连.由于建设道路是有花费的,因此Crash只修建了N-1条道路连接这些城市,不过可以保证任意两个城市都有路径相通.在游戏中,Crash需要选择一个城市作为他的国家的首都,选择首都需要考虑很多指标,有一个指标是这样的:$S(i)=\sum

[国家集训队]Crash的数字表格 / JZPTAB

题目描述 今天的数学课上,Crash小朋友学习了最小公倍数(Least Common Multiple).对于两个正整数a和b,LCM(a, b)表示能同时整除a和b的最小正整数.例如,LCM(6, 8) = 24. 回到家后,Crash还在想着课上学的东西,为了研究最小公倍数,他画了一张NM的表格.每个格子里写了一个数字,其中第i行第j列的那个格子里写着数为LCM(i, j).一个45的表格如下: 1 2 3 4 5 2 2 6 4 10 3 6 3 12 15 4 4 12 4 20 看着这

[bzoj2117] [2010国家集训队]Crash的旅游计划

静态信息的点分治. 老套路,对各个重心用数据结构维护所管辖的点到它的距离..再去重一波 查询的时候就直接二分了..如果数据结构用动态开点的线段树的话就可以直接在线段树上找了..不过我还是写了treap 时间复杂度O(nlog^3n) 1 #include<cstdio> 2 #include<iostream> 3 #include<cstring> 4 #include<cstdlib> 5 using namespace std; 6 const int

BZOJ2159 : Crash 的文明世界

$x^k=\sum_{i=1}^k Stirling2(k,i)\times i!\times C(x,i)$ 设$f[i][j]=\sum_{k=1}^n C(dist(i,k),j)$. 则可以利用$C(i,j)=C(i-1,j-1)+C(i-1,j)$,通过树形DP求出$f$. 时间复杂度$O((n+k)k)$. #include<cstdio> const int N=50010,M=155,P=10007; int n,k,i,j,x,y,S[M][M],fac[M],g[N],v[

「luogu1829」 [国家集训队]Crash的数字表格

莫比乌斯反演推柿子,数论分块降复杂度,最后时间复杂度为O(n). 1 #include<bits/stdc++.h> 2 #define ll long long 3 using namespace std; 4 const int N=1e7+10,mod=20101009; 5 int n,m,mi; 6 ll p[N],tot; 7 ll u[N]; 8 bool isp[N]; 9 void getu(int lim){ 10 u[1]=1; 11 for(int i=2;i<=

BZOJ 2159: Crash 的文明世界(树形dp+第二类斯特林数+组合数)

题意: 给定一棵 \(n\) 个点的树和一个常数 \(k\) , 对于每个 \(i\) , 求 \[\displaystyle S(i) = \sum _{j=1} ^ {n} \mathrm{dist}(i, j)^k\] \(n ≤ 50000, k ≤ 150\) 题解 : 先划划那个 \(S(i)\) 的式子 我们需要知道一个化 \(x^n(n \ge 0)\) 的东西qwq \[\displaystyle x^n=\sum_{k=0}^{n}\begin{Bmatrix} n \\ k

【题解】[国家集训队]Crash的数字表格 / JZPTAB

求解\(\sum_{i = 1}^{n}\sum_{j = 1}^{m}lcm\left ( i,j \right )\). 有\(lcm\left ( i,j \right )=\frac{ij}{gcd\left ( i,j \right )}\), 所以原本的式子转化为:\(\sum_{i = 1}^{n}\sum_{j = 1}^{m}\frac{ij}{gcd\left ( i,j \right )}\). 注意到\(i, j\) 均为 \(gcd\left ( i,j \right