【BZOJ5119】【CTT2017】生成树计数 DP 分治FFT 斯特林数

最新推荐文章于 2019-04-03 17:58:00 发布
最新推荐文章于 2019-04-03 17:58:00 发布
阅读量58 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/ywwyww/p/8513384.html
版权

　　
　　CTT=清华集训

题目大意

　　有\(n\)个点，点权为\(a_i\)，你要连接一条边，使该图变成一颗树。

　　对于一种连边方案\(T\)，设第\(i\)个点的度数为\(d_i\)，那么这棵树的价值为：
\[ val(T)=(\prod_{i=1}^na_i^{d_i}d_i^m)(\sum_{i=1}^nd_i^m) \]
　　求所有生成树的价值和\(\bmod 998244353\)

　　\(n\leq 30000,m\leq 30\)

题解

　　很容易想到prufer序列

　　先把式子化简：
\[ \begin{align} ans&=(\prod_{i=1}^na_i^{d_i}d_i^m)(\sum_{i=1}^nd_i^m)\\ &=\sum_{i=1}^nd_i^m(\prod_{j=1}^na_j^{d_j}d_j^m)\\ &=\sum_{i=1}^na_i^{d_i}d_i^{2m}(\prod_{j=1,j!=i}^na_j^{d_j}d_j^m)\\ \end{align} \]
　　就是得到排列后选一个数\(i\)，把贡献乘上\(d_i^m\)

　　考虑最简单的做法，记\(f_{i,j}\)为前\(i\)个数，占了\(j\)个空，没有额外的选择一个数的贡献，\(g_{i,j}\)就是选了一个数。

　　很容易得到DP式。这个DP是\(O(n^3)\)的，可以用FFT优化到\(O(n^2\log n)\)

　　注意到\(m\)很小，还记得那个乘方转组合数和斯特林数的套路吗？

　　先在prufer数列后面补上\(1\)~\(n\)，这样写了数字\(i\)的格子个数就是\(d_i\)

　　\(d_i^m\)就是用\(m\)种颜色染\(d_i\)个格子，每种颜色只能染一个格子，每个格子可以染多种颜色的方案数。

　　因为染了颜色的格子很少，所以枚举写了数字\(i\)的格子中染了颜色的格子数量\(k\)，如果染色的格子全在前面，方案数就是\(\binom{n-2-j}{k}\times S(m,k)\times k!\)，贡献就是\(a_i^{k+1}\)。后面有就是\(\binom{n-2-j}{k}\times S(m,k+1)\times (k+1)!\)

　　额外选一个数就把\(m\)改成\(2m\)

　　\(f_{i,j},g_{i,j}\)的意义和以前类似，只不过改成了染色的格子个数是\(j\)。

　　最后枚举染色的格子个数\(i\)，没染色的格子可以随便填数，要乘上\({(\sum_{i=1}^na_i)}^{n-2-i}\)

　　时间复杂度：\(O(n^2m)\)

　　把组合数什么的全部拆开后就能得到一个比较漂亮的式子（其中\(F,G,A,B\)都是多项式）：
\[ \begin{align} F_i&=F_{i-1}A\\ G_i&=G_{i-1}A+F_{i-1}B \end{align} \]
　　可以用分治FFT优化。

　　时间复杂度：\(O(nm\log^2 n)\)

代码

暴力

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<ctime>
#include<utility>
#include<cmath>
#include<functional>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
void sort(int &a,int &b)
{
    if(a>b)
        swap(a,b);
}
void open(const char *s)
{
#ifndef ONLINE_JUDGE
    char str[100];
    sprintf(str,"%s.in",s);
    freopen(str,"r",stdin);
    sprintf(str,"%s.out",s);
    freopen(str,"w",stdout);
#endif
}
int rd()
{
    int s=0,c;
    while((c=getchar())<'0'||c>'9');
    do
    {
        s=s*10+c-'0';
    }
    while((c=getchar())>='0'&&c<='9');
    return s;
}
int upmin(int &a,int b)
{
    if(b<a)
    {
        a=b;
        return 1;
    }
    return 0;
}
int upmax(int &a,int b)
{
    if(b>a)
    {
        a=b;
        return 1;
    }
    return 0;
}
const ll p=998244353;
ll h[62][62];
ll f[2][60010];
ll g[2][60010];
ll a[30010];
ll d[30010][62];
ll fac[30010];
ll ifac[30010];
ll inv[30010];
void add(ll &a,ll b)
{
    a=(a+b)%p;
}
ll fp(ll a,ll b)
{
    ll s=1;
    for(;b;b>>=1,a=a*a%p)
        if(b&1)
            s=s*a%p;
    return s;
}
ll getc(int x,int y)
{
    if(x<y)
        return 0;
    return fac[x]*ifac[y]%p*ifac[x-y]%p;
}
ll s1[60010][62];
ll s2[60010][62];
ll s3[60010][62];
ll s4[60010][62];
int main()
{
    freopen("a.in","r",stdin);
    freopen("a2.out","w",stdout);
    int n,m;
    scanf("%d%d",&n,&m);
    h[0][0]=1;
    int i,j,k;
    fac[0]=fac[1]=ifac[0]=ifac[1]=inv[0]=inv[1]=1;
    for(i=2;i<=2*m||i<=n;i++)
    {
        inv[i]=-p/i*inv[p%i]%p;
        fac[i]=fac[i-1]*i%p;
        ifac[i]=ifac[i-1]*inv[i]%p;
    }
    for(i=1;i<=2*m;i++)
        for(j=1;j<=2*m;j++)
            h[i][j]=(h[i-1][j-1]+h[i-1][j]*j)%p;
    for(i=0;i<=2*m;i++)
        for(j=0;j<=2*m;j++)
            h[i][j]=h[i][j]*fac[j]%p;
    for(i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
        d[i][0]=1;
        for(j=1;j<=2*m;j++)
            d[i][j]=d[i][j-1]*a[i]%p;
    }
    for(i=1;i<=n;i++)
        for(j=0;j<=2*m;j++)
        {
            s1[i][j]=ifac[j]*d[i][j]%p*((h[m][j]+h[m][j+1])%p)%p;
            s2[i][j]=ifac[j]*d[i][j]%p*((h[2*m][j]+h[2*m][j+1])%p)%p;
        }
    f[0][0]=1;
    int t=0;
    for(i=0;i<n;i++)
    {
        t^=1;
        memset(f[t],0,sizeof f[t]);
        memset(g[t],0,sizeof g[t]);
        for(j=0;j<=n-2;j++)
        {
            for(k=0;k<=m&&k<=n-2-j;k++)
            {
                add(f[t][j+k],f[t^1][j]*s1[i+1][k]);
                add(g[t][j+k],g[t^1][j]*s1[i+1][k]);
            }
            for(k=0;k<=2*m&&k<=n-2-j;k++)
                add(g[t][j+k],f[t^1][j]*s2[i+1][k]);
        }
    }
    ll ans=0,s=0;
    for(i=1;i<=n;i++)
        s=(s+a[i])%p;
    for(i=0;i<=n-2;i++)
        ans=(ans+g[t][i]*ifac[n-2-i]%p*fp(s,n-2-i))%p;
    for(i=1;i<=n;i++)
        ans=ans*a[i]%p;
    ans=ans*fac[n-2]%p;
    ans=(ans+p)%p;
    printf("%lld\n",ans);
    return 0;
}

正解

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<ctime>
#include<utility>
#include<cmath>
#include<functional>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
void sort(int &a,int &b)
{
    if(a>b)
        swap(a,b);
}
void open(const char *s)
{
#ifndef ONLINE_JUDGE
    char str[100];
    sprintf(str,"%s.in",s);
    freopen(str,"r",stdin);
    sprintf(str,"%s.out",s);
    freopen(str,"w",stdout);
#endif
}
int rd()
{
    int s=0,c;
    while((c=getchar())<'0'||c>'9');
    do
    {
        s=s*10+c-'0';
    }
    while((c=getchar())>='0'&&c<='9');
    return s;
}
int upmin(int &a,int b)
{
    if(b<a)
    {
        a=b;
        return 1;
    }
    return 0;
}
int upmax(int &a,int b)
{
    if(b>a)
    {
        a=b;
        return 1;
    }
    return 0;
}
const int p=998244353;
int fp(ll a,ll b)
{
    ll s=1;
    for(;b;b>>=1,a=1ll*a*a%p)
        if(b&1)
            s=1ll*s*a%p;
    return s;
}
namespace ntt
{
    const int g=3;
    int w1[150000];
    int w2[150000];
    int rev[150000];
    int n;
    void init(int m)
    {
        n=m;
        int i;
        for(i=2;i<=n;i<<=1)
        {
            w1[i]=fp(g,(p-1)/i);
            w2[i]=fp(w1[i],p-2);
        }
        rev[0]=0;
        for(i=1;i<n;i++)
            rev[i]=(rev[i>>1]>>1)|(i&1?n>>1:0);
    }
    void ntt(int *a,int t)
    {
        int u,v,w,wn;
        int i,j,k;
        for(i=0;i<n;i++)
            if(rev[i]<i)
                swap(a[i],a[rev[i]]);
        for(i=2;i<=n;i<<=1)
        {
            wn=(t==1?w1[i]:w2[i]);
            for(j=0;j<n;j+=i)
            {
                w=1;
                for(k=j;k<j+i/2;k++)
                {
                    u=a[k];
                    v=1ll*a[k+i/2]*w%p;
                    a[k]=(u+v)%p;
                    a[k+i/2]=(u-v)%p;
                    w=1ll*w*wn%p;
                }
            }
        }
        if(t==-1)
        {
            int inv=fp(n,p-2);
            for(i=0;i<n;i++)
                a[i]=1ll*a[i]*inv%p;
        }
    }
    void copy(int *a,const vector<int> &b,int len)
    {
        int i;
        for(i=0;i<=len;i++)
            a[i]=b[i];
        for(i=len+1;i<n;i++)
            a[i]=0;
    }
    vector<int> back(int *a,int len)
    {
        vector<int> s;
        int i;
        for(i=0;i<=len;i++)
            s.push_back(a[i]);
        return s;
    }
}
int n,m;
int h[62][62];
int f[2][60010];
int g[2][60010];
int a[30010];
int d[30010][62];
int fac[30010];
int ifac[30010];
int inv[30010];
void add(int &a,int b)
{
    a=(a+b)%p;
}
int s1[60010][62];
int s2[60010][62];
auto gao(vector<int> &a,vector<int> &b,vector<int> &c,vector<int> &d)
{
    static int a1[150000],a2[150000],a3[150000],a4[150000],s1[150000],s2[150000];
    int len=1;
    int n1=a.size()-1;
    int n2=b.size()-1;
    int n3=c.size()-1;
    int n4=d.size()-1;
    while(len<=2*n2||len<=2*n4)
        len<<=1;
    ntt::init(len);
    ntt::copy(a1,a,n1);
    ntt::copy(a2,b,n2);
    ntt::copy(a3,c,n3);
    ntt::copy(a4,d,n4);
    ntt::ntt(a1,1);
    ntt::ntt(a2,1);
    ntt::ntt(a3,1);
    ntt::ntt(a4,1);
    int i;
    for(i=0;i<len;i++)
    {
        s1[i]=1ll*a1[i]*a3[i]%p;
        s2[i]=(1ll*a1[i]*a4[i]+1ll*a2[i]*a3[i])%p;
    }
    ntt::ntt(s1,-1);
    ntt::ntt(s2,-1);
    return make_pair(ntt::back(s1,min(n-2,n1+n3)),ntt::back(s2,min(n-2,max(n1+n4,n2+n3))));
}
auto solve(int l,int r)
{
    if(l==r)
    {
        vector<int> a(m+1),b(2*m+1);
        int i;
        for(i=0;i<=2*m;i++)
        {
            if(i<=m)
                a[i]=s1[l][i];
            b[i]=s2[l][i];
        }
        return make_pair(a,b);
    }
    int mid=(l+r)>>1;
    auto L=solve(l,mid);
    auto R=solve(mid+1,r);
    return gao(L.first,L.second,R.first,R.second);
}
int main()
{
    open("a");
    scanf("%d%d",&n,&m);
    h[0][0]=1;
    int i,j,k;
    fac[0]=fac[1]=ifac[0]=ifac[1]=inv[0]=inv[1]=1;
    for(i=2;i<=2*m||i<=n;i++)
    {
        inv[i]=1ll*-p/i*inv[p%i]%p;
        fac[i]=1ll*fac[i-1]*i%p;
        ifac[i]=1ll*ifac[i-1]*inv[i]%p;
    }
    for(i=1;i<=2*m;i++)
        for(j=1;j<=2*m;j++)
            h[i][j]=(h[i-1][j-1]+1ll*h[i-1][j]*j)%p;
    for(i=0;i<=2*m;i++)
        for(j=0;j<=2*m;j++)
            h[i][j]=1ll*h[i][j]*fac[j]%p;
    for(i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        d[i][0]=1;
        for(j=1;j<=2*m;j++)
            d[i][j]=1ll*d[i][j-1]*a[i]%p;
    }
    for(i=1;i<=n;i++)
        for(j=0;j<=2*m;j++)
        {
            s1[i][j]=1ll*ifac[j]*d[i][j]%p*((1ll*h[m][j]+h[m][j+1])%p)%p;
            s2[i][j]=1ll*ifac[j]*d[i][j]%p*((1ll*h[2*m][j]+h[2*m][j+1])%p)%p;
        }
//  f[0][0]=1;
    int t=0;
//  for(i=0;i<n;i++)
//  {
//      t^=1;
//      memset(f[t],0,sizeof f[t]);
//      memset(g[t],0,sizeof g[t]);
//      for(j=0;j<=n-2;j++)
//      {
//          for(k=0;k<=m;k++)
//          {
//              add(f[t][j+k],f[t^1][j]*s1[i+1][k]);
//              add(g[t][j+k],g[t^1][j]*s1[i+1][k]);
//          }
//          for(k=0;k<=2*m;k++)
//              add(g[t][j+k],f[t^1][j]*s2[i+1][k]);
//      }
//  }
    auto dp=solve(1,n);
    int ans=0,s=0;
    for(i=1;i<=n;i++)
        s=(s+a[i])%p;
    for(i=0;i<=n-2;i++)
//      ans=(ans+g[t][i]*ifac[n-2-i]%p*fp(s,n-2-i))%p;
        ans=(ans+1ll*dp.second[i]*ifac[n-2-i]%p*fp(s,n-2-i))%p;
    for(i=1;i<=n;i++)
        ans=1ll*ans*a[i]%p;
    ans=1ll*ans*fac[n-2]%p;
    ans=(ans+p)%p;
    printf("%d\n",ans);
    return 0;
}

转载于:https://www.cnblogs.com/ywwyww/p/8513384.html

BZOJ4836(CDQ分治+FFT（NTT会T））
KKiseki的博客
08-26 437
题面 题目定义了一种奇怪的运算，是这样的 还给出了两个数组A,B，数组长度和元素大小都 有多个询问，给出一个k，问有多少对(i,j)使得 Ai opt Bj = k。 如果 x opt y = x+y，那么显然是一个桶状数组的卷积，FFT可以解决 若 x opt y = x-y，根据FFT题的套路，把一个数组反过来，发现它依然是个卷积。而题目把运算按x与y的大小关系分成了两种，两种都
[NOI2007]生成树计数（状压dp+矩阵加速）
cjk_My steps
05-28 679
【题解】 考虑动态规划的状态转移： 从左往右，加入第n个结点时，只考虑它向前连的边，那么答案就与向前连哪些边，以及之前的n-1个点构成的答案有关  然而，"向前连哪些边"并不是有2^k种情况  前n个点构成了许多连通块，而非一棵树  因此，结点n引出的边既要使结点1~n连通，也不能构成环  而n只能向 n-k ~ n-1 连边  所以n的答案只与结点n-k~n-1的连通性有关 
BZOJ5119 生成树计数（prufer+生成函数+分治FFT+多项式exp）
weixin_30361753的博客
04-03 128
　　https://www.luogu.org/problemnew/solution/P4002 神树的题解写的很清楚了。稍微补充： 　　1.[x^i]ln(A(ax))=a^i[x^i]ln(A(x))，感觉直接证并非那么显然，大约是先求出多项式再把ax作为自变量带回去。 　　2.最后一句中的式子，即考虑由ai组成的|S|=k的S集合在xk中被统计了几次，容易发现仅当这个Σ∏(1-ajx)...
bzoj1494 生成树计数（状压dp+生成树+矩阵倍增）
Icefox的博客
10-12 602
看数据，k<=5,n<=1e15,n极大，显然只能矩阵倍增去算。考虑dp，k极小，每个点最多能和前k个点连边，因此我们需要知道前k个点的联通情况，采用状压dp，用最小表示法。 我们可以先用一个DFS预处理出所有可能出现的连通性的状态。然后再枚举连通性状态S以及下一个点和S里的K个点中的哪些点连边，再判断从连通性状态S转移出来的新状态S′是否是合法的，若合法，在邻接矩阵里，标记从S到S′的方案数加1
【BZOJ-1016】最小生成树计数
Yu Gi Oh!
02-27 267
题目链接 题目描述 给出一个简单无向加权图。你不满足于求出这个图的最小生成树，而希望知道这个图中有多少个不同的最小生成树。（如果两颗最小生成树中至少有一条边不同，则这两个最小生成树就是不同的）。由于不同的最小生成树可能很多，所以你只需要输出方案数对31011的模就可以了。 题解 首先有如下定理: 一个无向图所有的最小生成树中某种权值的边的数目均相同。 (太弱不会证) 给出一...
【JSOI2008】 bzoj1016 最小生成树计数
YHaX的博客
07-30 1756
kruskal+dfs
[BZOJ Contest-2017省队十连测推广赛1·T2][BZOJ4766][完全二分图的生成树个数]文艺计算姬
CE玩家
03-07 1124
公式题 答案是nm−1∗mn−1n^{m-1}*m^{n-1}%p 快速幂的过程中会爆long long，所以还要打快速乘 #include #include #include using namespace std; typedef long long ll; ll n,m,p; inline ll mul(ll x,ll y,ll p){ if(x<y) swap(x,
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
（自己写的动态点分治巨垃圾，常数是别人的两倍） 用动态开点线段树死活过不去，学了一波大佬用 vector 开树状数组立马就卡过去了 考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的...
BZOJ4517 Sdoi2016 排列计数 【DP+组合计数】*
Dream_maker的博客
09-18 269
BZOJ4517 Sdoi2016 排列计数 Description 求有多少种长度为 n 的序列 A，满足以下条件： 1 ~ n 这 n 个数在序列中各出现了一次 若第 i 个数 A[i] 的值为 i，则称 i 是稳定的。序列恰好有 m 个数是稳定的 满足条件的序列可能很多，序列数对 10^9+7 取模。 Input 第一行一个数 T，表示有 T 组数据。 接下来 T 行，每行两个整数 n、m...
bzoj3193（计数dp）
KKiseki的博客
09-13 288
比赛是碰到的，还是不会做，我的dp已经菜不成声了。（传说只有智商超群的人才能做出这题）。 题面 语文变差了，只会复题目 有n座山，每座山有一个高度h和关键数字b。 现将这n座山排成一排，要求对于每座山排在其前面且比它高的山的数量小于它的关键数字。 询问不同的标号序列和等高线序列的数量是多少。 标号序列就是按顺序写下每座山的标号，等高线序列就是按顺序写下它们的高度。 由于每座山只受比它
BZOJ4313 三维积木 计数 dp
forever_shi的博客
11-25 354
题目链接 题意： 你有r块红色积木，b块蓝色积木和g块绿色积木，积木都是111的立方体，你要在n*n的格子上摆出主视图积木颜色全部相同的三维物体，要求所有的积木都要用上，问方案数，对1e9+7取模。r,b,g,n&lt;=25 题解： 一看就是一个比较复杂的计数题，一般还是从dp入手。我们先假设三种颜色中的某一种为主视图的颜色，那么对于其他两种颜色，我们可以先求出不对其进行区分的方案，再乘一个组合...
[BZOJ2873]-光之大陆-计数dp
泉華子的OI足迹
04-25 611
说在前面 并没有什么想说的，但是要保持格式=w= 题目 BZOJ2873传送门 题目大意 NNN 个点的「带环的树」计数。环与环不能共点，树不能有重边。答案对 MMM 取模 N≤200,M≤106N≤200,M≤106N\leq 200,M\leq 10^6 输入输出格式 输入格式： 一行两个数字N,MN,MN,M 输出格式： 输出一个数字表示答案 ...
BZOJ3456【分治FFT】
Lethelody的专栏
07-07 3527
然而会TLE. /* I will wait for you */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define make(a,b) make_p
【计数DP】BZOJ5219 [Lydsy2017省队十连测] 最长路径
MEET YOU FIRST TIME
02-06 618
【题目】 BZOJ 给定nnn，求一幅nnn个点的竞赛图（所有点对之间有一条有向边），对于i=1∼ni=1\sim ni=1∼n，从111出发的最长简单路径经过点数恰好为iii的竞赛图个数模PPP。n≤2000,P≤109n\leq 2000,P\leq 10^9n≤2000,P≤109 【解题思路】 对于竞赛图有一些性质： 竞赛图一定有哈密尔顿路径（即沿边访问每个顶点恰好一次 缩点之后按拓扑序...
[DP套DP] BZOJ 3864 Hero meet devil
雯舞
05-31 442
我们令fi,jf_{i,j}表示TiT_i和SjS_j的LCS 然后我们发现 fi,j−fi,j−1∈[0,1]f_{i,j}-f_{i,j-1} \in [0,1] 这个东西可以状压 预处理所有转移 然后DP#include<cstdio> #include<cstdlib> #include<algorithm> #include<cstring> #define cl(x) memset(
【BZOJ】4559: [JLoi2016]成绩比较 计数DP+排列组合+拉格朗日插值
weixin_33963189的博客
04-14 103
【题意】n位同学（其中一位是B神），m门必修课，每门必修课的分数是[1,Ui]。B神碾压了k位同学（所有课分数<=B神），且第x门课有rx-1位同学的分数高于B神，求满足条件的分数情况数。当有一位同学的一门必修课分数不同时视为两种情况不同。n,m<=100，Ui<=10^9。 【算法】计数DP+排列组合+拉格朗日插值 【题解】把分数作为状态不现实，只能逐门课考虑。 设$f[...
【BZOJ1079】[SCOI2008]着色方案【计数DP】【奇怪的姿势】
BraketBN
03-29 558
【题目链接】 想了一天多，感觉似乎只能是5^15。看了一下题解，发现还能这么玩... 神奇的题。 【iwtwiioi的题解】 /* Footprints In The Blood Soaked Snow */ #include using namespace std; typedef unsigned long long ULL; const int maxn = 16,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值