【UOJ#50】【UR #3】链式反应(分治FFT,动态规划)

【UOJ#50】【UR #3】链式反应(分治FFT,动态规划)

题面

UOJ

题解

首先把题目意思捋一捋,大概就是有\(n\)个节点的一棵树,父亲的编号大于儿子。
满足一个点的儿子有\(2+c\)个,其中\(c\in A\),且\(c\)个儿子是叶子,另外\(2\)个存在子树,且两种点的链接的边是不同的,求方案数。
那么就考虑一个暴力\(dp\),设\(f[i]\)表示有\(i\)个节点的树的个数。
那么枚举它两个有子树的子树大小,然后把编号给取出来,得到:
\[f[i]=\frac{1}{2}\sum_{j}\sum_{k} {i-1\choose j}{i-1-j\choose k}f[j]f[k]\]
其中存在限制,也就是\(i-1-j-k\in A\),要乘\(\frac{1}{2}\)是因为这两个子树选择的时候存在先后关系,所以同一棵子树可能会被计算两次。
这样子我们就可以做\(O(n^3)\)了。
然后把式子给拆一下:
\[{i-1\choose j}{i-1-j\choose k}=\frac{(i-1)!}{j!k!(i-1-j-k)!}\]
之和\(i,j,k\)相关的可以直接和\(f[i],f[j],f[k]\)丢到一起,剩下的只和\(i/j+k\)相关。
然后预处理\(g[i]=\sum_j \frac{f[j]}{j!}\frac{f[i-j]}{(i-j)!}\)。
那么
\[\frac{2f[i]}{(i-1)!}=\sum_{p=j+k}g[p]*[i-1-p\in A]\]
这样子就可以做到\(O(n^2)\)了。
进一步发现,\(g\)和\(\frac{2f}{(i-1)!}\)都是卷积的形式,所以可以直接分治\(FFT\)求解做到\(O(nlog^2)\)。
然而这里有细节、、、乱搞会挂。
注意到分治\(FFT\)的过程是\([l,mid]\rightarrow [mid+1,r]\),而\(g\)数组在求解的时候是\(f\)卷上\(f\),这样子会导致乘的数组的范围是\([0,r-l]\),可能存在一部分值没有被计算过。
而这个值具有对称性,所以我们强制\(j<k\)的时候才贡献\(2f[j]*f[k]\)。
也就是如果\(i<l\)的时候,数组里丢进去的是\(2f[i]\),当\(l\le i\le mid\)的时候丢\(f[i]\),否则丢\(0\)进去。
然后两个\(log\)就能过了。
然而这题看起来有更加优秀的做法,但是窝太菜了就不管了。

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define MOD 998244353
#define MAX 840000
int fpow(int a,int b){int s=1;while(b){if(b&1)s=1ll*s*a%MOD;a=1ll*a*a%MOD;b>>=1;}return s;}
int r[MAX],W[MAX];
void NTT(int *P,int opt,int len)
{
    int N,l=0;for(N=1;N<len;N<<=1)++l;
    for(int i=0;i<N;++i)r[i]=(r[i>>1]>>1)|((i&1)<<(l-1));
    for(int i=0;i<N;++i)if(i<r[i])swap(P[i],P[r[i]]);
    for(int i=1;i<N;i<<=1)
    {
        int w=fpow(3,(MOD-1)/(i<<1));W[0]=1;
        for(int k=1;k<i;++k)W[k]=1ll*W[k-1]*w%MOD;
        for(int j=0,p=i<<1;j<N;j+=p)
            for(int k=0;k<i;++k)
            {
                int X=P[j+k],Y=1ll*W[k]*P[i+j+k]%MOD;
                P[j+k]=(X+Y)%MOD;P[i+j+k]=(X+MOD-Y)%MOD;
            }
    }
    if(opt==-1)
    {
        reverse(&P[1],&P[N]);
        for(int i=0,inv=fpow(N,MOD-2);i<N;++i)P[i]=1ll*P[i]*inv%MOD;
    }
}
int jc[MAX],inv[MAX],jv[MAX];
int f[MAX],g[MAX],A[MAX];
int L[MAX],R[MAX];
void CDQ(int l,int r)
{
    if(l==r)
    {
        if(l==1)f[l]=1;
        else f[l]=1ll*f[l]*inv[2]%MOD*jc[l-1]%MOD;
        return;
    }
    int mid=(l+r)>>1,N;
    CDQ(l,mid);
    for(N=1;N<=mid-l+1+r-l;N<<=1);
    for(int i=l;i<=mid;++i)L[i-l]=g[i];
    for(int i=0;i<=r-l;++i)R[i]=A[i]*jv[i];
    NTT(L,1,N);NTT(R,1,N);
    for(int i=0;i<N;++i)L[i]=1ll*L[i]*R[i]%MOD;
    NTT(L,-1,N);
    for(int i=mid+1;i<=r;++i)f[i]=(f[i]+L[i-1-l])%MOD;
    for(int i=0;i<N;++i)L[i]=R[i]=0;
    for(int i=l;i<=mid;++i)L[i-l]=1ll*f[i]*jv[i]%MOD;
    for(int i=0;i<=r-l;++i)
        if(i<l)R[i]=2ll*f[i]*jv[i]%MOD;
        else if(i<=mid)R[i]=1ll*f[i]*jv[i]%MOD;
    NTT(L,1,N);NTT(R,1,N);
    for(int i=0;i<N;++i)L[i]=1ll*L[i]*R[i]%MOD;
    NTT(L,-1,N);
    for(int i=mid+1;i<=r;++i)g[i]=(g[i]+L[i-l])%MOD;
    for(int i=0;i<N;++i)L[i]=R[i]=0;

    CDQ(mid+1,r);
}
int n;
char ch[MAX];
int main()
{
    scanf("%d%s",&n,ch);
    for(int i=0;i<n;++i)A[i]=ch[i]-48;
    jc[0]=jv[0]=inv[0]=inv[1]=1;
    for(int i=2;i<=n;++i)inv[i]=1ll*inv[MOD%i]*(MOD-MOD/i)%MOD;
    for(int i=1;i<=n;++i)jc[i]=1ll*jc[i-1]*i%MOD;
    for(int i=1;i<=n;++i)jv[i]=1ll*jv[i-1]*inv[i]%MOD;
    f[1]=1;
    /*
    for(int i=2;i<=n;++i)
    {
        for(int j=0;j<=i;++j)g[i]=(g[i]+1ll*f[j]*jv[j]%MOD*f[i-j]%MOD*jv[i-j]%MOD)%MOD;
        for(int j=0;j<i;++j)
            if(A[i-1-j])
                f[i]=(f[i]+1ll*g[j]*jv[i-1-j])%MOD;
        f[i]=1ll*f[i]*inv[2]%MOD*jc[i-1]%MOD;
    }
    */
    CDQ(1,n);
    for(int i=1;i<=n;++i)printf("%d\n",f[i]);
    return 0;
}

原文地址:https://www.cnblogs.com/cjyyb/p/11055520.html

时间: 2024-10-28 01:52:41

【UOJ#50】【UR #3】链式反应(分治FFT,动态规划)的相关文章

【UOJ#22】【UR #1】外星人(动态规划)

[UOJ#22][UR #1]外星人(动态规划) 题面 UOJ 题解 一道简单题? 不难发现只有按照从大往小排序的顺序选择的才有意义,否则先选择一个小数再去模一个大数是没有意义的. 设\(f[i][j]\)表示考虑了前\(i\)个数,模完之后是\(j\)的方案数. 转移的时候枚举这个数是模还是不模,如果不模的话就要把它放到后面某个小数的后面,方案数是\(n-i\). #include<iostream> #include<cstdio> #include<cstdlib>

五大常用算法:分治、动态规划、贪心、回溯和分支界定

苹果的WWDC ,除了发布了os x 10.10 和IOS8 外,还推出了Swift.详细点击这里 代码总体风格有点像Java,也有点像javascript. 下面给出一些代码段(来自苹果官方手册): println("Hello, world") "var myVariable = 42 myVariable = 50 let myConstant = 42" 摘录来自: Apple Inc. "The Swift Programming Languag

2017 3 11 分治FFT

考试一道题的递推式为$$f[i]=\sum_{j=1}^{i} j^k \times (i-1)! \times \frac{f[i-j]}{(i-j)!}$$这显然是一个卷积的形式,但$f$需要由自己卷过来(我也不知到怎么说),以前只会生成函数的做法,但这题好像做不了(谁教教我怎么做),于是无奈的写了一发暴力,看题解发现是分治FFT.分治每层用$f[l]-f[mid]$与$a[1]-a[r-l]$做NTT.这样显然每个$f[l]-f[mid]$对$f[mid+1]-f[r]$的贡献都考虑到了.

【xsy1529】小Q与进位制 - 分治FFT

题意很简单,就是求这个数... 其实场上我想出了分治fft的正解...然而不会打...然后打了个暴力fft挂了... 没啥好讲的,这题很恶心,卡常卡精度还爆int,要各种优化,有些dalao写的很复杂我都没看懂...我写的是每三位拆分然后再合并 代码: 1 //强烈谴责卡常数而需要大量优化 2 //upd:还卡精度... 3 #include<algorithm> 4 #include<iostream> 5 #include<cstring> 6 #include&l

五类常见算法小记 (递归与分治,动态规划,贪心,回溯,分支界限法)

近日复习了一些算法知识,小记于此 递归与分治法 直接或间接地调用自身的算法称为递归算法. 递归是算法设计与分析中常用的一种技术,描述简单且易于理解. 分治法的设计思想是将一个规模为n难以解决的问题分解为k个规模较小的子问题,这些子问题相互独立且与原问题相同. 递归地解这些子问题,然后将各子问题的解合并得到原问题的解. 典型例子:Fibonacci数列,阶乘,Hanoi塔:二分法搜索.快速排序.合并排序. 动态规划法 动态规划过程是:根据当前(阶段)状态,采取相应的决策,引起状态的转移.如下图,一

【bzoj4836】[Lydsy2017年4月月赛]二元运算 分治+FFT

题目描述 定义二元运算 opt 满足 现在给定一个长为 n 的数列 a 和一个长为 m 的数列 b ,接下来有 q 次询问.每次询问给定一个数字 c 你需要求出有多少对 (i, j) 使得 a_i  opt b_j=c . 输入 第一行是一个整数 T (1≤T≤10) ,表示测试数据的组数. 对于每组测试数据: 第一行是三个整数 n,m,q (1≤n,m,q≤50000) . 第二行是 n 个整数,表示 a_1,a_2,?,a_n (0≤a_1,a_2,?,a_n≤50000) . 第三行是 m

HDU Shell Necklace CDQ分治+FFT

Shell Necklace Problem Description Perhaps the sea‘s definition of a shell is the pearl. However, in my view, a shell necklace with n beautiful shells contains the most sincere feeling for my best lover Arrietty, but even that is not enough. Suppose

看无可看 分治FFT+特征值方程

题面: 看无可看(see.pas/cpp/c) 题目描述 “What’s left to see when our eyes won’t open?” “若彼此瞑目在即,是否终亦看无可看?” ------来自网易云音乐<Golden Leaves-Passenger> 最后的一刻我看到了...... 一片昏暗? 我记起来了, 我看到,那里有一个集合S,集合S中有n个正整数a[i](1<=i<=n) 我看到,打破昏暗的密码: 记忆中的f是一个数列,对于i>1它满足f(i)=2*

【BZOJ3451】Tyvj1953 Normal 点分治+FFT+期望

[BZOJ3451]Tyvj1953 Normal Description 某天WJMZBMR学习了一个神奇的算法:树的点分治!这个算法的核心是这样的:消耗时间=0Solve(树 a) 消耗时间 += a 的 大小 如果 a 中 只有 1 个点  退出 否则在a中选一个点x,在a中删除点x 那么a变成了几个小一点的树,对每个小树递归调用Solve我们注意到的这个算法的时间复杂度跟选择的点x是密切相关的.如果x是树的重心,那么时间复杂度就是O(nlogn)但是由于WJMZBMR比较傻逼,他决定随机