A

Pro

传送门

Sol

考虑将前后两部分差距最大化，显然前一部分放得是前$n$小的，后一部分放的是前$n$大的，于是排序即可。

#include <bits/stdc++.h>
#define MAXN 2005
using namespace std;
inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while (ch<'0'||ch>'9'){
		if (ch=='-') f=-1;
		ch=getchar();
	}
	while (ch>='0'&&ch<='9'){
		x=(x<<1)+(x<<3)+(ch^'0');
		ch=getchar();
	}
	return x*f;
}
int a[MAXN];
int main(){
	int n=read();
	for (register int i=1;i<=n*2;++i){
		a[i]=read();
	}
	sort(a+1,a+1+n*2);
	int sum1=0,sum2=0;
	for (register int i=1;i<=n;++i){
		sum1+=a[i];
	}
	for (register int i=n+1;i<=n*2;++i){
		sum2+=a[i];
	}
	if (sum1!=sum2) {
		for (register int i=1;i<=2*n;++i){
			printf("%d ",a[i]);
		}
	}
	else {
		puts("-1");
	}
}

B

Pro

传送门

Sol

考虑一个数$a_i$要和$a_j$交换，如果他们两个奇偶性不同，那么直接交换即可。
如果他们两个奇偶性相同，那么假设存在一个和他们俩奇偶性不同的$a_k$，$swap(a_i,a_k),swap(a_k,a_j)$即可。

这样我们在不影响整个序列其他数的情况下交换了两个数。

再考虑选择排序，只要能交换序列中任意两个数，就可以将序列变得有序，于是这样是可以使序列从小到大排序的。

什么时候不行？序列里面只有一种奇偶性，此时输出原序列。

#include <bits/stdc++.h>
#define MAXN 100005
using namespace std;
inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while (ch<'0'||ch>'9'){
		if (ch=='-') f=-1;
		ch=getchar();
	}
	while (ch>='0'&&ch<='9'){
		x=(x<<1)+(x<<3)+(ch^'0');
		ch=getchar();
	}
	return x*f;
}
int a[MAXN];
int main(){
	int n=read();
	bool flag1=true,flag2=true;
	for (register int i=1;i<=n;++i){
		a[i]=read();
		if (!(a[i]&1)) flag1=false;
		else flag2=false;
	}
	if ((!flag1)&&(!flag2)) sort(a+1,a+1+n);//两种奇偶性都有
	for (register int i=1;i<=n;++i){
		printf("%d ",a[i]);
	}
}

C

Pro

传送门

Sol

考虑一个诡异的想法，题目要求$gcd(i,j)==1$则$a_i != a_j$，不妨这么想$gcd(i,j) != 1$，我们都让$a_i,a_j$相等。
这样的话，我们只要把$2,3,5,7,11...$的倍数分别设成相同的数即可。

#include <bits/stdc++.h>
#define MAXN 100005
using namespace std;
inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while (ch<'0'||ch>'9'){
		if (ch=='-') f=-1;
		ch=getchar();
	}
	while (ch>='0'&&ch<='9'){
		x=(x<<1)+(x<<3)+(ch^'0');
		ch=getchar();
	}
	return x*f;
}
int prime[MAXN],stk[MAXN],ans[MAXN],top;
int main(){
	int n=read();
	prime[0]=prime[1]=true;
	prime[2]=false;
	for (register int i=2;i<=n;++i){
		if (!prime[i]){
			stk[++top]=i;
			for (register int j=i*2;j<=n;j+=i){
				prime[j]=true;
			}
		}
	}
	int num=0;
	for (register int i=top;i>=1;--i){
		int p=stk[i];
		num++;
		for (register int j=p;j<=n;j+=p){
			if (!ans[j]) ans[j]=num;
		}
	}
	for (register int i=2;i<=n;++i){
		printf("%d ",ans[i]);
	}
}

D

Pro

传送门

Sol

首先，看到连续的异或和就要想到把他们转化为前缀和的异或，记$sum[i]=a[1] \oplus a[2] \oplus ... \oplus a[i]$，那么$a[l] \oplus ... \oplus a[r]=sum[r] \oplus a[l-1]$

转化为不存在$sum[i]=sum[j]$或者$sum[i]=x \oplus sum[j]$

这该怎么搞？

有一个很玄学的贪心，考虑记录$use[]$数组，代表$sum[i]$有没有出现，依次扫过去，如果$i$没有用，那么加入$i$，并且标记$i\oplus x$，考虑正确性，因为$a\oplus x==b \oplus x$推出$a==b$，那么肯定不会把$use[i\oplus x]$弄重复，而且$i\oplus x$一定大于$i$，如果小于的话，在$i\oplus x$的地方$i \oplus x \oplus x = i$已经被标记过了，矛盾。

use[0]=use[x]=1;
for (register int i=0;i<(1<<n);++i){
	if (!use[i]) use[i^x]=true,sum[++top]=i;
}

但是这样只能证明是合理的解，但是最优性不知道怎么证。

就当一个结论来记算了。

#include <bits/stdc++.h>
#define MAXN (1<<18)+5
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
int sum[MAXN],use[MAXN],top;
int main(){
	int n=read(),x=read();
	use[0]=use[x]=1;
	for (register int i=0;i<(1<<n);++i){
		if (!use[i]) use[i^x]=true,sum[++top]=i;
	}
	printf("%d\n",top);
	for (register int i=1;i<=top;++i){
		printf("%d ",sum[i]^sum[i-1]);
	}
}

$10pt$

输出$0$，出题人还是很良心的

$30pt$

最简单的暴搜

#include <bits/stdc++.h>
#define MAXN 1000005
#define MOD 1000000007
using namespace std;
inline int read() {
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9') {
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9') {
        x=(x*10)+(ch-'0');
        ch=getchar();
    }
    return x*f;
}
//还有$BB$，$GG$，$BG$，$GB$的总数，分别为$a$，$b$，$c$，$d$
int ans,n;
int num[MAXN];
void dfs(int i,int a,int b,int c,int d){
    if (a<0||b<0||c<0||d<0) return ;
    if (i==n+1&&a==0&&b==0&&c==0&&d==0) {
        ans=(ans+1)%MOD;
        return ;
    }
    if (num[i-1]==0){
        num[i]=0;
        dfs(i+1,a-1,b,c,d);
        num[i]=1;
        dfs(i+1,a,b,c-1,d);
    }
    else {
        num[i]=0;
        dfs(i+1,a,b,c,d-1);
        num[i]=1;
        dfs(i+1,a,b-1,c,d);
    }
}
int main(){
    n=read();
    int a=read(),b=read(),c=read(),d=read();
    num[1]=0;
    dfs(2,a,b,c,d);
    num[1]=1;
    dfs(2,a,b,c,d);
    printf("%d\n",ans);
}

$100pt$

我们考虑$a,b,c,d$对$B$，$G$的贡献，发现贡献$sumb=2a+c+d$，$sumg=2b+c+d$
其中中间部分的贡献算了两次，头和尾的贡献只算了一次，如果知道首尾的字母，就能知道整个序列中$B,G$的个数。

我们再把序列抽象成一段一段的$B$，$G$
如$.....GB.....BG......GB......BG.....$
我们发现$BG$，$GB$只出现在交界处。
所以我们发现一个很简单的性质：$abs(c-d)<=2$。
再yy一下
发现若$c==d$，那么序列首尾都为$G$或者都为$B$，
若$c==d+1$，那么序列首部为$B$，尾部为$G$，
若$c+1==d$，那么序列首部为$G$，尾部为$B$，
根据这个性质，我们就可以求出$B,G$的数量，若总数$>n$，则排列数为$0$

剩下的部分组合数爆推一波就可以了：
我们发现知道了头尾的字母，就知道了$B$区间和$G$区间的段数和位置。
考虑插板法，将$A$个字母分成$s1$段，每段不为$0$，总方法数：$C^{s1-1}_{A-1}$
把插入$B$的方法数和插入$G$的方法数相乘即可。

代码细节比较多

#include <bits/stdc++.h>
#define MAXN 2000005
#define MOD 1000000007
#define int long long
using namespace std;
inline int read() {
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9') {
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9') {
        x=(x*10)+(ch-'0');
        ch=getchar();
    }
    return x*f;
}
inline int Abs(int a){
    return a>0?a:-a;
}
int fac[MAXN],inv[MAXN];
inline int ksm(int b,int k){
    int ans=1;
    while (k){
        if (k&1) ans=(ans*b)%MOD;
        b=(b*b)%MOD;
        k>>=1;
    }
    return ans;
}
inline void Init(){
    fac[0]=1;
    for (register int i=1;i<MAXN;++i){
        fac[i]=(fac[i-1]*i)%MOD;
    }
}
inline int C(int n,int m){
    if (n==0) return 1;
    if (n==-1&&m==-1) return 1;
    return fac[m]*ksm(fac[n],MOD-2)%MOD*ksm(fac[m-n],MOD-2)%MOD;
}
int n;
inline int Solve(int A,int B,int s1,int s2){//s1段A个数 s2段B个数
    if (A+B!=n) return 0; 
    return C(s1-1,A-1)*C(s2-1,B-1)%MOD;
}
//还有BB，GG，BG，GB的总数，分别为a，b，c，d
#undef int
int main(){
#define int long long
    Init();
    n=read();int a=read(),b=read(),c=read(),d=read();
    if (Abs(c-d)>=2){
        puts("0");
        return 0;
    }
    int sumb=a*2+c+d;
    int sumg=b*2+c+d;
    int ans=0;
    //算出汉子妹子总数（相邻的算重复）
    if (c==d){//两种情况：头尾为BB，或者GG
        if (sumb&1||sumg&1) {
            puts("0");
            return 0;
        }
        else {
            ans+=Solve((sumb+2)/2,sumg/2,c+1,c);
            ans+=Solve(sumb/2,(sumg+2)/2,c,c+1);
        }
    }
    else{//头尾一定为BG或GB
        if ((!(sumb&1))||(!(sumg&1))){
            puts("0");
            return 0;
        }
        else {
            ans+=Solve((sumb-1)/2+1,(sumg-1)/2+1,max(c,d),max(c,d));//两种情况合起来写
        }
    }
    printf("%lld\n",ans);
}

p.s.可以在介里下载数据点击下载

Splay写法：

// luogu-judger-enable-o2
#include <bits/stdc++.h>
#define MAXN 200005
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
int fa[MAXN],ch[MAXN][2],size[MAXN],tag[MAXN];
#define lc(i) ch[i][0]
#define rc(i) ch[i][1]
inline void pushup(int i){
    size[i]=size[lc(i)]+size[rc(i)]+1;
}
inline void pushdown(int i){
    if (tag[i]){
        tag[i]^=1;
        tag[lc(i)]^=1,tag[rc(i)]^=1;
        swap(lc(i),rc(i));
    }
}
inline void rotate(int x,int &k){
    int y=fa[x],z=fa[y];
    bool p=(lc(y)==x);
    if (y==k) k=x;
    else {
        if (lc(z)==y) lc(z)=x;
        else rc(z)=x;
    }
    ch[y][!p]=ch[x][p];
    fa[ch[y][!p]]=y,ch[x][p]=y;
    fa[y]=x,fa[x]=z;
    pushup(x),pushup(y);
}
inline void splay(int x,int &k){
    while (x!=k){
        int y=fa[x],z=fa[y];
        if (y!=k){
            if ((lc(y)==x)^(lc(z)==y)) rotate(x,k);
            else rotate(y,k);
        }
        rotate(x,k);
    }
}
void build(int l,int r,int f){
    if (l>r) return ;
    int mid=(l+r)>>1;
    if (mid<f) lc(f)=mid;
    else rc(f)=mid;
    fa[mid]=f;size[mid]=1;
    if (l==r) return ;
    build(l,mid-1,mid),build(mid+1,r,mid);
    pushup(mid);
}
int Find(int x,int k){
    pushdown(x);
    if (k==size[lc(x)]+1) return x;
    else if (k<=size[lc(x)]) return Find(lc(x),k);
    else return Find(rc(x),k-size[lc(x)]-1);
}
int root;
void Update(int l,int r){
    int x=Find(root,l),y=Find(root,r+2);
    splay(x,root),splay(y,rc(x));
    tag[lc(y)]^=1;
}
int main(){
    int n=read(),m=read();
    root=(n+3)/2,build(1,n+2,root);
    for (register int i=1;i<=m;++i){
        int l=read(),r=read();
        Update(l,r);
    }
    for (register int i=2;i<=n+1;++i){
        printf("%d ",Find(root,i)-1);
    }
}

FHQ Treap写法：

#include <bits/stdc++.h>
#define MAXN 100005
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
namespace FHQTreap{
    struct node{
        int l,r;
        int pri,val,sz;
        bool tag;
    }tree[MAXN];
    #define lc(i) tree[i].l
    #define rc(i) tree[i].r
    inline void pushup(int i){
        tree[i].sz=tree[lc(i)].sz+tree[rc(i)].sz+1;
    }
    inline void pushdown(int i){
        if (tree[i].tag){
            swap(lc(i),rc(i));
            tree[lc(i)].tag^=1;
            tree[rc(i)].tag^=1;
            tree[i].tag=false;
        }
    }
    void Split(int i,int k,int &x,int &y){
        pushdown(i);
        if (i==0) return x=y=0,void();
        if (tree[lc(i)].sz>=k){
            y=i;
            Split(lc(i),k,x,lc(y));
            pushup(y);
        }
        else {
            x=i;
            Split(rc(i),k-tree[lc(i)].sz-1,rc(x),y);
            pushup(x);
        }
    }
    int Merge(int x,int y){
        if (!x||!y) return x+y;
        pushdown(x),pushdown(y);
        if (tree[x].pri>tree[y].pri){
            lc(y)=Merge(x,lc(y));
            pushup(y);
            return y;
        }
        else {
            rc(x)=Merge(rc(x),y);
            pushup(x);
            return x;
        }
    }
    int root,tot;
    inline void Reverse(int l,int r){
        int x,y,z;
        Split(root,l-1,x,y);
        Split(y,r-l+1,y,z);
        tree[y].tag^=1;
        root=Merge(x,Merge(y,z));
    }
    void Print(int i){
        if (!i) return ;
        pushdown(i);
        Print(lc(i));
        printf("%d ",tree[i].val);
        Print(rc(i));
    }
    int New(int val){
        tree[++tot].sz=1;
        tree[tot].pri=rand();
        tree[tot].val=val;
        tree[tot].l=tree[tot].r=tree[tot].tag=0;
        return tot;
    }
}
using namespace FHQTreap;
int main(){
    int n=read(),m=read();
    for (register int i=1;i<=n;++i) root=Merge(root,New(i));
    for (register int i=1;i<=m;++i){
        int l=read(),r=read();
        Reverse(l,r);
    }
    Print(root);
}

好了步入正题：
考虑在线段树的每个节点开一棵$\rm FHQ Treap$，维护的是线段树左右端点$[l,r]$所代表的区间$a_l...a_r$
这样不会$\rm MLE$，因为线段树最多有$\log n$层，而每一层就算填满也只有$O(n)$的空间，所以总空间复杂度是$O(n \log n)$，注意数组要开这么大

$1.$建树：对于节点$[l,r]$，暴力插入$a[l]...a[r]$，时间复杂度$O(n\log^2n)$。
$2.$替换$a[pos]$为$k$：对于包含$pos$的区间$[l,r]$，先删除$a[pos]$，再加入$k$，时间复杂度$O(\log^2n)$。
$3.$查询区间中$num$的排名：我们发现：$num$的排名为区间中小于$num$的数的数量$+1$，又发现线段树的区间查询操作其实将查询区间$[L,R]$分成许多不相交的小区间，根据这个，我们把$num$在小区间的排名$-1$，得到在小区间中小于$num$的数的数量，最后相加，发现小于$num$的数的数量不会重复计算，于是把和$+1$，得到$num$在区间$[L,R]$的排名，时间复杂度$O(\log^2n)$
这里很容易跳进的坑：不能把$num$在小区间中的排名相加，否则$num$会重复算很多次
$4.$查询区间第$k$大的数：因为$\rm FHQ Treap$只能查询$num$的排名，所以考虑二分$num$，时间复杂度$O(\log^3n)$，查询$num$排名$O(\log^2n)$，二分$O(\log n)$。
（当然按照子树大小$\rm Split$，$\rm FHQTreap$也阔以支持查询第$k$大，详情请戳这里）
$5.$查询区间中，$num$的前驱：直接把小区间中$num$的所有前驱取个$max$。
$6.$查询区间中，$num$的后继：类似$5.$

注意要判断$num$的前驱后继是否存在，若不存在，相应地输出$\rm INF/-INF$。
还有修改操作做完后，要执行$a[pos]=k$，修改$a$数组。

#include <bits/stdc++.h>
#define MAXN 50005
#define MAXM 10000005
#define INF 0x7fffffff
using namespace std;
inline int read() {
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9') {
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9') {
        x=(x*10)+(ch-'0');
        ch=getchar();
    }
    return x*f;
}
int a[MAXN];
struct node{
	int l,r;
	int val;//每个点的权值 
	int pri;//优先级（随机生成）
	int sz;
}tree[MAXM];
int tot;
struct FHQ_Treap{
	#define lc(i) tree[i].l
	#define rc(i) tree[i].r
	inline void Update(int x){tree[x].sz=tree[lc(x)].sz+tree[rc(x)].sz+1;}
	inline int New(int v){
		tree[++tot].val=v,tree[tot].pri=rand(),tree[tot].sz=1;
		return tot;
	}
	int Merge(int x,int y){
		if (!x||!y) return x+y;
		if (tree[x].pri<tree[y].pri){
            rc(x)=Merge(rc(x),y),Update(x);
            return x;
        }
		else{
            lc(y)=Merge(x,lc(y)),Update(y);
			return y;
        }
	}
	void Split(int i,int k,int &x,int &y){
		if (!i) x=y=0;
		else {
			if (tree[i].val<=k){x=i,Split(rc(i),k,rc(i),y);}
			else{y=i,Split(lc(i),k,x,lc(i));}
			Update(i);
		}
	}
    int root,x,y,z;
    inline void Add(int num){
		Split(root,num,x,y);
		root=Merge(x,Merge(New(num),y));
    }
    inline void Del(int num){
		Split(root,num,x,z);
		Split(x,num-1,x,y);
		y=Merge(lc(y),rc(y));
		root=Merge(Merge(x,y),z);
    }
    inline int Rank(int num){//获得num排名
        Split(root,num-1,x,y);
        int temp=tree[x].sz+1;
		root=Merge(x,y);
        return temp;
    }
    inline int Kth(int i,int rk){
    	if (rk<=tree[lc(i)].sz) return Kth(lc(i),rk);
    	if (rk==tree[lc(i)].sz+1) return tree[i].val;
    	return Kth(rc(i),rk-tree[lc(i)].sz-1);
	}
	inline int Pre(int num){
		Split(root,num-1,x,y);
		int ans=tree[x].sz?Kth(x,tree[x].sz):-INF;
		root=Merge(x,y);
		return ans;
	}
	inline int Nex(int num){
		Split(root,num,x,y);
		int ans=tree[y].sz?Kth(y,1):INF;
		root=Merge(x,y);
		return ans;
	}
    inline void BuildTree(int l,int r){
        for (register int i=l;i<=r;++i){Add(a[i]);}
    }
    #undef lc
    #undef rc
}T[MAXN<<2];
int n;
namespace SegmentTree{
    #define lc i<<1
    #define rc i<<1|1
    void Build(int i,int l,int r){
        T[i].BuildTree(l,r);
        if (l==r) return ;
        int mid=(l+r)>>1;
        Build(lc,l,mid);
        Build(rc,mid+1,r);
    }
    int qrank(int i,int l,int r,int L,int R,int val){
        if (L<=l&&r<=R) {
            return T[i].Rank(val)-1;
        }
        int mid=(l+r)>>1;
        int ans=0;
        if (L<=mid) ans+=qrank(lc,l,mid,L,R,val);
        if (mid<R) ans+=qrank(rc,mid+1,r,L,R,val);
        return ans;
    } 
    inline int qval(int l,int r,int rk){
        int L=0,R=0x7fffffff;
        int ans=-1;
        while (L<=R){
            int mid=(L+R)>>1;
            if (qrank(1,1,n,l,r,mid)<rk) ans=mid,L=mid+1;
            else R=mid-1;
        }
        return ans;
    }
    void Update(int l,int r,int i,int k,int pos){//a[pos]=>k
        T[i].Del(a[pos]),T[i].Add(k);
        if (l==r) return ;
        int mid=(l+r)>>1;
        if (pos<=mid) Update(l,mid,lc,k,pos);
        else Update(mid+1,r,rc,k,pos);
    }
    int qpre(int i,int l,int r,int L,int R,int val){
        if (L<=l&&r<=R){
            return T[i].Pre(val);
        }
        int mid=(l+r)>>1;
        int ans=-0x7fffffff;
        if (L<=mid) ans=max(ans,qpre(lc,l,mid,L,R,val));
        if (mid<R) ans=max(ans,qpre(rc,mid+1,r,L,R,val));
        return ans;
    }
    int qnex(int i,int l,int r,int L,int R,int val){
        if (L<=l&&r<=R){
            return T[i].Nex(val);
        }
        int mid=(l+r)>>1;
        int ans=0x7fffffff;
        if (L<=mid) ans=min(ans,qnex(lc,l,mid,L,R,val));
        if (mid<R) ans=min(ans,qnex(rc,mid+1,r,L,R,val));
        return ans;
    }
    #undef lc
    #undef rc
}
using namespace SegmentTree;
int main(){
    n=read();int m=read();
    for (register int i=1;i<=n;++i){
        a[i]=read();
    }
    Build(1,1,n);
    while (m--){
        int opr=read();
        if (opr==1){
            int l=read(),r=read(),k=read();
            printf("%d\n",qrank(1,1,n,l,r,k)+1);
        }
        else if (opr==2){
            int l=read(),r=read(),k=read();
            printf("%d\n",qval(l,r,k));
        }
        else if (opr==3){
            int pos=read(),k=read();
            Update(1,n,1,k,pos),a[pos]=k;
        }
        else if (opr==4){
            int l=read(),r=read(),k=read();
            printf("%d\n",qpre(1,1,n,l,r,k));
        }
        else if (opr==5){
            int l=read(),r=read(),k=read();
            printf("%d\n",qnex(1,1,n,l,r,k));
        }
    }
}

答案上界为该无向图中的偶点数量，考虑构造方案达到这个上界
建一个虚点S向所有奇点连边，这样奇点都变成了偶点，而奇点的个数一定是偶数，故S也是个偶点
于是新图存在欧拉回路，根据这个对边进行定向，则原图中所有偶点入度等于出度，达到上界

#include <bits/stdc++.h>
#define MAXN 205
using namespace std;
int G[MAXN][MAXN];
inline int read() {
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9') {
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9') {
        x=(x*10)+(ch-'0');
        ch=getchar();
    }
    return x*f;
}
int deg[MAXN];
inline void AddEdge(int u,int v){
    G[u][v]=G[v][u]=1;
    deg[u]++,deg[v]++;
}
inline void DelEdge(int u,int v){
    G[u][v]=G[v][u]=0;
    deg[u]--,deg[v]--;
}
int n,m;
void dfs(int u){
    for (register int i=1;i<=n+1;++i){
        if (G[u][i]){
            if (i!=n+1&&u!=n+1){
                printf("%d %d\n",u,i);
            }
            DelEdge(i,u);
            dfs(i);
        }
    }
}
int main(){
    int t=read();
    while (t--){
        n=read(),m=read();
        for (register int i=1;i<=m;++i){
            int u=read(),v=read();
            AddEdge(u,v);
        }
        int ans=0;
        for (register int i=1;i<=n;++i){
            if (deg[i]&1){//奇点
                AddEdge(i,n+1);
            }
            else {
                ans++;
            }
        }
        printf("%d\n",ans);
        for (register int i=1;i<=n;++i) dfs(i);;;
    }
}

$\sum _{i=0} ^ {\log_2n} 2^i =n$（注意这里的等于只是量级上面的等于）

画长方形法

例题1

归并排序时间复杂度$T(n)=2T(\frac{n}{2})+O(n)$

可以画图分析，显然每层都是$n$，有$\log n$层，所以是$O(n\log n)$

例题2

$T(n)=4T(\frac{n}{2}) + n$

可以看出只有$\log n$层，但是每层相比于上层都乘了$2$。

总共$n\sum _{i=0}^{\log n} 2^i = n^2$

首先，遇到等差数列这种形式，最先要想到移项。

$A[k]-A[j]=A[j]-A[i] \to A[k]+A[i]=2 \times A[j]$

于是很容易想到固定$j$，而在$j$两边枚举$i,k$。

注意到如果固定$j$，$2 \times A[j]$为常数，于是可以构造生成函数$F_{left}=\sum _{i=0}^\infty [i \in A[1]...A[j-1]] x^i$，$F_{right}=\sum _{i=0}^\infty [i \in A[j+1]...A[n]] x^i$。

$F_{left} \times F_{right}$中$x^{2 \times A[j]}$的系数就是答案。

但是注意到如果这样每次都要两边构造生成函数，然后计算，是$O(n^2 \log n)$的。

发现从$j$到$j+1$的过程中，变化的$F_{left}$和$F_{right}$并不多，每次重新$FFT$似乎有些浪费，而且每次$FFT$只能计算出一个数的贡献。

于是我们毒瘤地想到，我们要扩大$F_{left},F_{right}$每次变化的次数，比如每次让它变化$\sqrt{n}$个数。

于是可以采用分块，对于$i,j,k$中两个以上的数在同一个块的情况，暴力解决：

inline void Query1(int id){//k在i,j右边
	int lb=(id-1)*Size+1,rb=min(id*Size,n);
	memset(Right,0,sizeof(Right));
	Add(Right,rb+1,n);//注意去掉
	for (register int j=lb+1;j<=rb;++j){//枚举中间的j
		for (register int i=lb;i<j;++i){//枚举左边的i
			if (2*A[j]-A[i]>=0) ans+=Right[2*A[j]-A[i]];
		}
	}
}

$Query1$计算的是$i,j$在编号为$id$的块，而$k$在$i,j$右边，而且不在$i,j$所在的块的情况。

inline void Query2(int id){
	int lb=(id-1)*Size+1,rb=min(id*Size,n);
	memset(Left,0,sizeof(Left));
	Add(Left,1,rb-1);
	for (register int j=rb-1;j>=lb;--j){//枚举中间的j
		Left[A[j]]--;
		for (register int k=j+1;k<=rb;++k){//枚举右边的k
			if (2*A[j]-A[k]>=0) ans+=Left[2*A[j]-A[k]];
		}
	}
}

$Query2$计算的是$i,j$在编号为$id$的块，而$k$在$i,j$左边的情况。

这样可以做到不重不漏。

剩下$FFT$非常好写，只要把$1\to lb-1$和$rb+1 \to n$ 的$A[i]$丢进$Left$和$Right$两个数组卷积即可。

时间复杂度分析：假设块大小为$sz$，暴力时间复杂度$O(sz \times n)$，$FFT$时间复杂度为$O( \frac{n}{sz} \times \sqrt {n \log n})$。

于是总时间复杂度为$O(sz \times n + \frac{n}{sz} \times n\log n)$

搞一下均值，$sz + \frac{1}{sz} \times n\log n \le 2 \times \sqrt {n \log n}$

于是$sz=\sqrt{n \log n}$时最优。

实测$sz=2600$最优。

时间复杂度$O(n \sqrt {n \log n})$

#include <bits/stdc++.h>
#define MAXN 200005
using namespace std;
inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while (ch<'0'||ch>'9'){
		x=(x<<1)+(x<<3)+(ch^'0');
		ch=getchar();
	}
	while (ch>='0'&&ch<='9'){
		x=(x<<1)+(x<<3)+(ch^'0');
		ch=getchar();
	}
	return x*f;
}
namespace FFT{
	const double PI=acos(-1.0);
	struct Complex{
    	double x,y;
	}a[MAXN],b[MAXN];
	inline Complex operator + (const Complex &A,const Complex &B){
	    return Complex{A.x+B.x,A.y+B.y};
	}
	inline Complex operator - (const Complex &A,const Complex &B){
	    return Complex{A.x-B.x,A.y-B.y};
	}
	inline Complex operator * (const Complex &A,const Complex &B){
	    return Complex{A.x*B.x-A.y*B.y,A.x*B.y+A.y*B.x};
	}
	int r[MAXN];
	inline void FFT(Complex *A,int n,int type){
	    for (register int i=0;i<n;++i) if (i<r[i]) swap(A[i],A[r[i]]);
	    for (register int i=1;i<n;i<<=1){
	        int R=i<<1;
	        Complex Wn=Complex{cos(2*PI/R),type*sin(2*PI/R)};
	        for (register int j=0;j<n;j+=R){
	            Complex w=Complex{1,0};
	            for (register int k=0;k<i;++k,w=w*Wn){
	                Complex x=A[j+k],y=w*A[i+j+k];
	                A[j+k]=x+y,A[i+j+k]=x-y;
	            }
	        }
	    }
	}
	int m,L;
	inline void Init(int len){
		m=1,L=0;
	    while (m<=2*len) m<<=1,L++;
	    memset(r,0,sizeof(r));
	    for (register int i=0;i<=m;++i){
	        r[i]=(r[i>>1]>>1|((i&1)<<(L-1)));
	    }
	}
	inline void Mul(int *des,int *A,int *B,int len){
		Init(len);
		for (register int i=0;i<=len;++i) a[i]=Complex{(double)A[i],0},b[i]=Complex{(double)B[i],0};
		for (register int i=len+1;i<m;++i) a[i]=Complex{0,0},b[i]=Complex{0,0};
		FFT(a,m,1),FFT(b,m,1);
		for (register int i=0;i<m;++i) a[i]=a[i]*b[i];
		FFT(a,m,-1);
		for (register int i=0;i<=len;++i) des[i]=(int)((double)a[i].x/m+0.5);
	}
}
using namespace FFT;
int A[MAXN],id[MAXN],Size,Max;
inline void Add(int *F,int l,int r){
	for (register int i=l;i<=r;++i){
		F[A[i]]++,Max=max(Max,A[i]);
	}
}
//A[k]-A[j]=A[j]-A[i]
//A[k]+A[i]=2*A[j]
//找到j
int Left[MAXN],Right[MAXN],res[MAXN];
long long ans;
int n;
inline void Query1(int id){//k在i,j右边 
	int lb=(id-1)*Size+1,rb=min(id*Size,n);
	memset(Right,0,sizeof(Right));
	Add(Right,rb+1,n);//注意去掉
	for (register int j=lb+1;j<=rb;++j){//枚举中间的j
		for (register int i=lb;i<j;++i){//枚举左边的i
			if (2*A[j]-A[i]>=0) ans+=Right[2*A[j]-A[i]];
		}
	}
}
inline void Query2(int id){
	int lb=(id-1)*Size+1,rb=min(id*Size,n);
	memset(Left,0,sizeof(Left));
	Add(Left,1,rb-1);
	for (register int j=rb-1;j>=lb;--j){//枚举中间的j
		Left[A[j]]--;
		for (register int k=j+1;k<=rb;++k){//枚举右边的k
			if (2*A[j]-A[k]>=0) ans+=Left[2*A[j]-A[k]];
		}
	}
}
int main(){
	n=read();
	for (register int i=1;i<=n;++i){
		A[i]=read();
	}
	Size=sqrt(n*log(n)/log(2));
	for (register int i=1;i<=n;++i){
		id[i]=(i-1)/Size+1;
	}
	for (register int i=1;i<=id[n];++i){//计算每个块中的 
		Query1(i),Query2(i);
	}
	int temp=ans;
	for (register int i=2;i<=id[n]-1;++i){
		int lb=(i-1)*Size+1,rb=min(i*Size,n);
		memset(Left,0,sizeof(Left)),memset(Right,0,sizeof(Right));
		Max=0;
		Add(Left,1,lb-1),Add(Right,rb+1,n);//两边的构造生成函数
		Mul(res,Left,Right,Max*2);
		for (register int j=lb;j<=rb;++j){
			ans+=res[A[j]*2];
		}
	}
	printf("%lld\n",ans);
}

考虑$Solve$算法，每个点有且仅有一次被当做树的根，于是可以将整个算法的期望时间复杂度变成每个点的树的期望大小之和。

想到这里，你还得有一个更加恶臭的想法，考虑如何表示每个点的树的期望大小，记$p[i][j]$为$j$在$i$子树里面的概率。

那么$i$子树的期望大小即是$\sum _{j!=i} p[i][j]$。

如何计算$p[i][j]$，考虑$i$到$j$的路径上共$dis(i,j)+1$个点，只有$i$是第一个被选择的点时，$i$和$j$才不会被分开，于是$p[i][j]=\frac{1}{dis(i,j)+1}$。

如何计算$\sum _{i=1}^n \sum _{j=1} ^n \frac{1}{dis(i,j)+1}$。

我们转换一下，假设等于$k$的$dis(i,j)$有$cnt[k]$个，答案即是$\sum cnt[k] \times \frac{1}{k+1}$

这个$cnt[k]$可以$FFT$+点分治去做。

考虑求出过当前树的根节点的路径数，设生成函数$F(x)=\sum _{i=0}^\infty dep(i) x^i$。其中$dep(i)$代表深度为$i$的节点个数。

$F(x)^2=\sum _{i=0}^\infty (\sum _{j=0}^i dep(j) dep(i-j)) x^i$，即是$\sum _{i=0}^\infty route(i) x^i$，其中$route(i)$代表路径个数。

这样算可能会有重复，于是按照点分治的套路需要容斥一下。

#include <bits/stdc++.h>
#define MAXN 500005
using namespace std;
inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while (ch<'0'||ch>'9'){
		if (ch=='-') f=-1;
		ch=getchar();
	}
	while (ch>='0'&&ch<='9'){
		x=(x<<1)+(x<<3)+(ch^'0');
		ch=getchar();
	}
	return x*f;
}
const double PI=acos(-1.0);
struct Complex{
    double x,y;
};
inline Complex operator + (const Complex &A,const Complex &B){
    return Complex{A.x+B.x,A.y+B.y};
}
inline Complex operator - (const Complex &A,const Complex &B){
    return Complex{A.x-B.x,A.y-B.y};
}
inline Complex operator * (const Complex &A,const Complex &B){
    return Complex{A.x*B.x-A.y*B.y,A.x*B.y+A.y*B.x};
}
Complex A[MAXN];
int r[MAXN];
inline void FFT(Complex *A,int n,int type){
    for (register int i=0;i<n;++i) if (i<r[i]) swap(A[i],A[r[i]]);
    for (register int i=1;i<n;i<<=1){
        int R=i<<1;
        Complex Wn=Complex{cos(2*PI/R),type*sin(2*PI/R)};
        for (register int j=0;j<n;j+=R){
            Complex w=Complex{1,0};
            for (register int k=0;k<i;++k,w=w*Wn){
                Complex x=A[j+k],y=w*A[i+j+k];
                A[j+k]=x+y,A[i+j+k]=x-y;
            }
        }
    }
	if (type==-1){
    	for (register int i=0;i<n;++i) A[i].x/=(double)n;
	}
}
int d[MAXN],ret[MAXN],ans[MAXN],sz;
inline void Mul(int f){
	int m=1,L=0;
	while (m<=2*sz) m<<=1,L++;
	for (register int i=0;i<=m;++i){
		r[i]=r[i>>1]>>1|((i&1)<<(L-1));
	}
	FFT(A,m,1);
	for (register int i=0;i<m;++i) A[i]=A[i]*A[i];
	FFT(A,m,-1);
	for (register int i=0;i<=sz*2;++i) ans[i]+=f*(int)(A[i].x+0.5);//深度可能变成两倍（恶臭）
	for (register int i=0;i<=m;++i) A[i].x=0,A[i].y=0;
}

vector<int>G[MAXN];
inline void AddEdge(int u,int v){
	G[u].push_back(v);
}
int dp[MAXN],max_dp[MAXN],vis[MAXN],tot,root;
inline void InitDP(int u,int father){
	dp[u]=1,max_dp[u]=0;
	for (register int i=0;i<(int)G[u].size();++i){
		int v=G[u][i];
		if (v!=father&&!vis[v]){
			InitDP(v,u);
			dp[u]+=dp[v];
			max_dp[u]=max(max_dp[u],dp[v]);
		}
	}
	max_dp[u]=max(max_dp[u],tot-dp[u]);
	if (max_dp[root]>max_dp[u]) root=u;
}
int n;
inline int GetRoot(int u,int s){
	tot=s,root=0;
	InitDP(u,0);
	return root;
}
inline void InitDep(int u,int father,int dep){
	sz=max(sz,dep);
	A[dep].x++;
	for (register int i=0;i<(int)G[u].size();++i){
		int v=G[u][i];
		if (v!=father&&!vis[v]){
			InitDep(v,u,dep+1);
		}
	}
}
inline void Calc(int u,int f){
	sz=0;
	InitDep(u,0,f==-1?1:0);
	Mul(f);
}
inline void dfs(int u){
	vis[u]=true;
	Calc(u,1);
	for (register int i=0;i<(int)G[u].size();++i){
		int v=G[u][i];
		if (!vis[v]){
			Calc(v,-1);
			dfs(GetRoot(v,dp[v]));
		}
	}
}
int main(){
	n=read();
	max_dp[0]=n;
	for (register int i=1;i<n;++i){
		int u=read()+1,v=read()+1;
		AddEdge(u,v);
		AddEdge(v,u);
	}
	dfs(GetRoot(1,n));
	double ret=0;
	for (register int i=0;i<n;++i){
		ret+=(double)ans[i]/(i+1);
	}
	printf("%.4lf\n",ret);
}

很好的一道生成函数+NTT题，做完之后可以加深对生成函数的理解。

建议先弄懂卡特兰数是怎么用生成函数推的，参考这篇博客（只用看推到$C(x)=\frac{1\pm\sqrt{1-4x}}{2}$的部分）

考虑我们是怎么推导出$n$节点二叉树的种类数为卡特兰数的，考虑根节点两边连出的子树，他们的方案数为$c_{n-i-1} \times c_{i}$。于是答案即是$\sum_{j=0}^{i-1} c_{n-j-1} \times c_j$

这道题的递推式也非常像上面的：

$F_n=1+\sum _{i=1}^n [i \in c] \sum _{j=0}^{k-i} F_jF_{i-j-k}$

（$1$代表左右子树是空的）

$[]$中的值为真时，代表的数为$1$，否则为$0$。

如法炮制，我们构造生成函数$G(x)=\sum _{i=0}^\infty [i \in c] x^i$。

设生成函数$F(x) =\sum _{i=0}^\infty cnt(i) x^i$，其中$cnt(i)$代表答案，即权值为$i$的神犇二叉树的总数。

于是递推式也是惊人的相似：$F=1+G \times F \times F$。$G$枚举了根节点的权值。

我们可以求出$F=\frac{1 \pm \sqrt{1-4G}}{2G}$，其中需要舍弃$\frac{1+\sqrt{1-4G}}{2G}$，因为其不收敛。

得到$F=\frac{1-\sqrt{1-4G}}{2G}$，我们还要进一步分子有理化，得出$F=\frac{2}{1+\sqrt{1-4G}}$。

我们需要多项式开根和多项式求逆，不会的请转到这里

代码：

#include <bits/stdc++.h>
#define MAXN 500005
#define MOD 998244353
#define invG 332748118
#define GG 3
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
inline int ksm(int b,int k){
	int ans=1;
	while (k){
		if (k&1) ans=(1ll*ans*b)%MOD;
		b=(1ll*b*b)%MOD;
		k>>=1;
	}
	return ans;
}
int r[MAXN],C[MAXN];
inline void NTT(int *A,int n,int type){
    for (register int i=0;i<n;++i) if (i<r[i]) swap(A[i],A[r[i]]);
    for (register int i=1;i<n;i<<=1){
        int R=i<<1;
        int Gn=ksm(type==1?GG:invG,(MOD-1)/R);
        for (register int j=0;j<n;j+=R){
        	int g=1;
            for (register int k=0;k<i;++k,g=(1ll*g*Gn)%MOD){
                int x=A[j+k],y=(1ll*g*A[i+j+k])%MOD;
                A[j+k]=(x+y)%MOD,A[i+j+k]=(x-y+MOD)%MOD;
            }
        }
    }
}
inline int get_inv(int x){
	return ksm(x,MOD-2);
}
int m,L;
inline void Init(int len){
	m=1,L=0;
	while (m<2*len) m<<=1,L++;
	for (register int i=0;i<m;++i){
		r[i]=(r[i>>1]>>1|((i&1)<<(L-1)));
	}
}
inline void Inv(int *A,int *B,int len){
	if (len==1){
		B[0]=get_inv(A[0]);
		return ;
	}
	Inv(A,B,(len+1)>>1);
	Init(len);
	for (register int i=0;i<len;++i) C[i]=A[i];
	for (register int i=len;i<m;++i) C[i]=0;
	NTT(C,m,1),NTT(B,m,1);
	for (register int i=0;i<m;++i){
		B[i]=(2ll-1ll*B[i]*C[i]%MOD+MOD)*B[i]%MOD;
	}
	NTT(B,m,-1);
    int inv=get_inv(m);
	for (register int i=0;i<len;++i) B[i]=(1ll*B[i]*inv)%MOD;
	for (register int i=len;i<m;++i) B[i]=0;
}
int D[MAXN],inv2;
inline void Sqrt(int *A,int *B,int len){
	if (len==1){
		B[0]=A[0];
		return ;
	}
	Sqrt(A,B,(len+1)>>1);
	for (register int i=0;i<(len<<1);++i) D[i]=0;
	Inv(B,D,len);
	Init(len);
	for (register int i=0;i<len;++i) C[i]=A[i];
	for (register int i=len;i<m;++i) C[i]=0;
	NTT(B,m,1),NTT(C,m,1),NTT(D,m,1);
	for (register int i=0;i<m;++i){
		B[i]=1ll*inv2*(1ll*C[i]*D[i]%MOD+B[i])%MOD;
	}
	NTT(B,m,-1);
	int inv=get_inv(m);
	for (register int i=0;i<len;++i) B[i]=(1ll*B[i]*inv)%MOD;
	for (register int i=len;i<m;++i) B[i]=0;
}
int G[MAXN],F[MAXN];
int S1[MAXN],Ans1[MAXN];
int S2[MAXN],Ans2[MAXN];
int main(){
	int n=read(),len=read();
	inv2=ksm(2,MOD-2);//要初始化，要不然死的很惨（这个错误至少花了我1h）
	G[0]=1;
	for (register int i=1;i<=n;++i){
		G[read()]++;
	}
	S1[0]=1;
	for (register int i=1;i<=len;++i){
		S1[i]=(-4ll*G[i]%MOD+MOD)%MOD;
	}
	Sqrt(S1,Ans1,len+1);
	Ans1[0]=(Ans1[0]+1)%MOD;
	Inv(Ans1,Ans2,len+1);
	for (register int i=1;i<=len;++i){
		printf("%d\n",2ll*Ans2[i]%MOD);
	}
}

有时候，题目要求对一个大质数（特别是998244353之类的数）取模，就不能用FFT，而是用NTT。

NTT采用原根替代单位根，如果不了解原根，请参考这篇博客。

常见NTT质数表：

采用NTT编写A*B problem。

代码如下：

#include <bits/stdc++.h>
#define MAXN 240005
#define MOD 998244353
#define invG 332748118 //G的逆元
#define G 3
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
inline int ksm(int b,int k){
	int ans=1;
	while (k){
		if (k&1) ans=(1ll*ans*b)%MOD;
		b=(1ll*b*b)%MOD;
		k>>=1;
	}
	return ans;
}
static int r[MAXN],a[MAXN],b[MAXN];
inline void NTT(int *A,int n,int type){
    for (register int i=0;i<n;++i) if (i<r[i]) swap(A[i],A[r[i]]);
    for (register int i=1;i<n;i<<=1){
        int R=i<<1;
        int Gn=ksm(type==1?G:invG,(MOD-1)/R);
        for (register int j=0;j<n;j+=R){
        	int g=1;
            for (register int k=0;k<i;++k,g=(1ll*g*Gn)%MOD){
                int x=A[j+k],y=(1ll*g*A[i+j+k])%MOD;
                A[j+k]=(x+y)%MOD,A[i+j+k]=(x-y+MOD)%MOD;
            }
        }
    }
}
char s1[MAXN],s2[MAXN];
int ans[MAXN];
int main(){
    int n=read();
    scanf("%s%s",s1+1,s2+1);
    for (register int i=1;i<=n;++i) a[i-1]=s1[n-i+1]-'0';
    for (register int i=1;i<=n;++i) b[i-1]=s2[n-i+1]-'0';
    int m=1,L=0;
    while (m<=2*n) m<<=1,L++;
    for (register int i=0;i<=m;++i){
        r[i]=(r[i>>1]>>1|((i&1)<<(L-1)));
    }
    NTT(a,m,1),NTT(b,m,1);
    for (register int i=0;i<=m;++i) a[i]=(1ll*a[i]*b[i])%MOD;
    NTT(a,m,-1);
    int inv=ksm(m,MOD-2);
    for (register int i=0;i<=m;++i){
        ans[i]+=(1ll*a[i]*inv)%MOD;//要乘上m的逆元
        ans[i+1]+=ans[i]/10,ans[i]%=10;
    }
    while (ans[m]==0) m--;
    for (register int i=m;i>=0;--i) putchar(ans[i]+'0');
}

常见多项式运算

这里才是重点部分。

多项式求逆

传送门

给你一个多项式$A$，要你求出一个多项式$B$，满足$AB=1\pmod {x^n}$

系数对$998244353$取模。

首先，理解$\pmod {x^n}$是为了去掉后面的部分。

下文中的除法全部代表向下取整。

我们假设求出了一个$B'$，满足$AB'=1\pmod{x^{\frac{n}{2}}}$，我们要求$B$，满足$AB=1 \pmod{x^n}$。其实就是一个小范围的解推出大范围的解。

那么我们有后面的部分$B-B'=0 \pmod{x^{\frac{n}{2}}}$

根据套路，我们要把后面的模数搞成$x^n$，于是两边平方。

$(B-B')^2=0\pmod{x^n}$

拆开$B^2 -2BB'+B'^2=0 \pmod{x^n}$

两边同时乘$A$，发现可以消掉很多。

$AB^2-2ABB'+AB'^2=0\pmod{x^n}$

显然$AB=1$，可以消掉，变成：

$B-2B'+AB'^2=0 \pmod{x^n}$

得出$B=2B'-AB'^2=B'(2-AB') \pmod{x^n}$

于是可以根据这个公式从一个小的解推出大的。

别忘了边界条件$A[0]=B[0]^{-1}$。

#include <bits/stdc++.h>
#define MAXN 1000005
#define MOD 998244353
#define invG 332748118
#define G 3
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
inline int ksm(int b,int k){
	int ans=1;
	while (k){
		if (k&1) ans=(1ll*ans*b)%MOD;
		b=(1ll*b*b)%MOD;
		k>>=1;
	}
	return ans;
}
int r[MAXN],C[MAXN];
inline void NTT(int *A,int n,int type){
    for (register int i=0;i<n;++i) if (i<r[i]) swap(A[i],A[r[i]]);
    for (register int i=1;i<n;i<<=1){
        int R=i<<1;
        int Gn=ksm(type==1?G:invG,(MOD-1)/R);
        for (register int j=0;j<n;j+=R){
        	int g=1;
            for (register int k=0;k<i;++k,g=(1ll*g*Gn)%MOD){
                int x=A[j+k],y=(1ll*g*A[i+j+k])%MOD;
                A[j+k]=(x+y)%MOD,A[i+j+k]=(x-y+MOD)%MOD;
            }
        }
    }
}
inline int get_inv(int x){
	return ksm(x,MOD-2);
}
int m,L;
inline void Init(int len){
	m=1,L=0;
	while (m<2*len) m<<=1,L++;
	for (register int i=0;i<m;++i){
		r[i]=(r[i>>1]>>1|((i&1)<<(L-1)));
	}
}
inline void Inv(int *A,int *B,int len){
	if (len==1){
		B[0]=get_inv(A[0]);
		return ;
	}
	Inv(A,B,(len+1)>>1);//注意是向上取整
	Init(len);
	for (register int i=0;i<len;++i) C[i]=A[i];//只用前面一部分
	for (register int i=len;i<m;++i) C[i]=0;
	NTT(C,m,1),NTT(B,m,1);
	for (register int i=0;i<m;++i){
		B[i]=(2ll-1ll*B[i]*C[i]%MOD+MOD)*B[i]%MOD;
	}
	NTT(B,m,-1);
    int inv=get_inv(m);
	for (register int i=0;i<len;++i) B[i]=(1ll*B[i]*inv)%MOD;//推完之后B'->B
	for (register int i=len;i<m;++i) B[i]=0;//多出来的部分要舍去
}
int F[MAXN],Ans[MAXN];
int main(){
	int n=read();
	for (register int i=0;i<n;++i) F[i]=read();
	Inv(F,Ans,n);
	for (register int i=0;i<n;++i) printf("%d ",Ans[i]);
}

分治FFT

传送门

此题我们使用生成函数做法。

构造生成函数$f(x)=\sum_{i=0}^\infty f[i] \times x^i,g(x)=\sum_{i=0}^\infty g[i] \times x^i$。

注意到$f(x)*g(x)=f(x)$。

欸这个有问题吧，这个应该无解才对啊！

再看一眼题目，注意到$f(x) \times g(x)$没有取到$x^0$

怎么办呢？补上一个$1$即可。（也可以这么理解，卷积起来之后整体后移了一位，所以要补上）

得到式子$f(x)*g(x)+1=f(x)$

解得$f(x)(1-g(x))=1$。

因为只用求前$n$项，转化为$f(x)(1-g(x))=1 \pmod{x^n}$

于是$f(x)=(1-g(x))^{-1} \pmod{x^n}$。

对于生成函数做法，还有一个解释，暴力做法是每次分别求出$f[i]$，而生成函数做法是一起解出$f$。

代码：

#include <bits/stdc++.h>
#define MAXN 1000005
#define MOD 998244353
#define invG 332748118
#define G 3
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
inline int ksm(int b,int k){
	int ans=1;
	while (k){
		if (k&1) ans=(1ll*ans*b)%MOD;
		b=(1ll*b*b)%MOD;
		k>>=1;
	}
	return ans;
}
int r[MAXN],C[MAXN];
inline void NTT(int *A,int n,int type){
    for (register int i=0;i<n;++i) if (i<r[i]) swap(A[i],A[r[i]]);
    for (register int i=1;i<n;i<<=1){
        int R=i<<1;
        int Gn=ksm(type==1?G:invG,(MOD-1)/R);
        for (register int j=0;j<n;j+=R){
        	int g=1;
            for (register int k=0;k<i;++k,g=(1ll*g*Gn)%MOD){
                int x=A[j+k],y=(1ll*g*A[i+j+k])%MOD;
                A[j+k]=(x+y)%MOD,A[i+j+k]=(x-y+MOD)%MOD;
            }
        }
    }
}
inline int get_inv(int x){
	return ksm(x,MOD-2);
}
int m,L;
inline void Init(int len){
	m=1,L=0;
	while (m<2*len) m<<=1,L++;
	for (register int i=0;i<m;++i){
		r[i]=(r[i>>1]>>1|((i&1)<<(L-1)));
	}
}
inline void Inv(int *A,int *B,int len){
	if (len==1){
		B[0]=get_inv(A[0]);
		return ;
	}
	Inv(A,B,(len+1)>>1);
	Init(len);
	for (register int i=0;i<len;++i) C[i]=A[i];
	for (register int i=len;i<m;++i) C[i]=0;
	NTT(C,m,1),NTT(B,m,1);
	for (register int i=0;i<m;++i){
		B[i]=(2ll-1ll*B[i]*C[i]%MOD+MOD)*B[i]%MOD;
	}
	NTT(B,m,-1);
    int inv=get_inv(m);
	for (register int i=0;i<len;++i) B[i]=(1ll*B[i]*inv)%MOD;
	for (register int i=len;i<m;++i) B[i]=0;
}
int F[MAXN],Ans[MAXN];
int main(){
	int n=read();
	F[0]=1;
	for (register int i=1;i<n;++i) F[i]=(-read()+MOD)%MOD;
	Inv(F,Ans,n);
	for (register int i=0;i<n;++i) printf("%d ",Ans[i]);
}

多项式开根

传送门

给你一个$n-1$次多项式$A(x)$，求$B(x)$，使得$B(x)^2=A(x) \pmod{x^n}$

还是多项式求逆的套路。

考虑现在已经求出$B'(x)$，使得$B'(x) ^2 = A(x) \pmod{x^{\frac{n}{2}}}$。

求出一个$B(x)$使得$B(x)^2=A(x)\pmod{x^{n}}$。

两边相减

$B(x)^2-B'(x)^2=0\pmod{x^{\frac{n}{2}}}$。

$(B(x)+B'(x))(B(x)-B'(x))=0 \pmod{x^{\frac{n}{2}}}$

显然$B(x)+B'(x)!=0$。

有$B(x)-B'(x)=0\pmod{x^\frac{n}{2}}$。

还是老套路，两边平方。

$B(x)^2-2B(x)B'(x)+B'(x)^2=0\pmod{x^n}$

注意到$B(x)^2=A(x)$。

代入得：

$A(x)-2B(x)B'(x)+B'(x)^2=0\pmod{x^n}$。

所以$B(x)=\frac{A(x)+B'(x)^2}{2B'(x)}=inv(2) *(A(x)B'^{-1}(x)+B'(x))$

再次套用多项式求逆的模板即可。

边界$B[0]=\sqrt {A[0]}=1$。

代码：

#include <bits/stdc++.h>
#define MAXN 1000005
#define MOD 998244353
#define invG 332748118
#define G 3
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
inline int ksm(int b,int k){
	int ans=1;
	while (k){
		if (k&1) ans=(1ll*ans*b)%MOD;
		b=(1ll*b*b)%MOD;
		k>>=1;
	}
	return ans;
}
int r[MAXN],C[MAXN];
inline void NTT(int *A,int n,int type){
    for (register int i=0;i<n;++i) if (i<r[i]) swap(A[i],A[r[i]]);
    for (register int i=1;i<n;i<<=1){
        int R=i<<1;
        int Gn=ksm(type==1?G:invG,(MOD-1)/R);
        for (register int j=0;j<n;j+=R){
        	int g=1;
            for (register int k=0;k<i;++k,g=(1ll*g*Gn)%MOD){
                int x=A[j+k],y=(1ll*g*A[i+j+k])%MOD;
                A[j+k]=(x+y)%MOD,A[i+j+k]=(x-y+MOD)%MOD;
            }
        }
    }
}
inline int get_inv(int x){
	return ksm(x,MOD-2);
}
int m,L;
inline void Init(int len){
	m=1,L=0;
	while (m<2*len) m<<=1,L++;
	for (register int i=0;i<m;++i){
		r[i]=(r[i>>1]>>1|((i&1)<<(L-1)));
	}
}
inline void Inv(int *A,int *B,int len){
	if (len==1){
		B[0]=get_inv(A[0]);
		return ;
	}
	Inv(A,B,(len+1)>>1);
	Init(len);
	for (register int i=0;i<len;++i) C[i]=A[i];
	for (register int i=len;i<m;++i) C[i]=0;
	NTT(C,m,1),NTT(B,m,1);
	for (register int i=0;i<m;++i){
		B[i]=(2ll-1ll*B[i]*C[i]%MOD+MOD)*B[i]%MOD;
	}
	NTT(B,m,-1);
    int inv=get_inv(m);
	for (register int i=0;i<len;++i) B[i]=(1ll*B[i]*inv)%MOD;
	for (register int i=len;i<m;++i) B[i]=0;
}
int D[MAXN],inv2;
inline void Sqrt(int *A,int *B,int len){
	if (len==1){
		B[0]=A[0];
		return ;//保证a_0=1
	}
	Sqrt(A,B,(len+1)>>1);
	for (register int i=0;i<(len<<1);++i) D[i]=0;
	Inv(B,D,len);//得出B^-1(x)
	Init(len);
	for (register int i=0;i<len;++i) C[i]=A[i];
	for (register int i=len;i<m;++i) C[i]=0;
	NTT(B,m,1),NTT(C,m,1),NTT(D,m,1);//B:目标 C:A(x) D:B^-1(x)
    //注意要做三次NTT
	for (register int i=0;i<m;++i){
		B[i]=1ll*inv2*(1ll*C[i]*D[i]%MOD+B[i])%MOD;
	}
	NTT(B,m,-1);
	int inv=get_inv(m);
	for (register int i=0;i<len;++i) B[i]=(1ll*B[i]*inv)%MOD;
	for (register int i=len;i<m;++i) B[i]=0;
}
int F[MAXN],Ans[MAXN];
int main(){
	inv2=ksm(2,MOD-2);
	int n=read();
	for (register int i=0;i<n;++i) F[i]=read();
	Sqrt(F,Ans,n);
	for (register int i=0;i<n;++i) printf("%d ",Ans[i]);
}

例题

例题1

P4841 城市规划

此题即是数据加强版POJ1737，题解在此

这里不再讨论$dp$方程式，而是着重讨论优化方法。

我们有$F(i)=2^{C_i^2} - \sum_{j=1}^{i-1} F(j) \times 2^{C_{i-j}^2} \times C_{i-1}^{j-1}$。

爆拆一波$C$，有$C_{i-1}^{j-1}=\frac{(i-1)!}{(i-j)!(j-1)!}$。

两边同时除$(i-1)!$，得$\frac{F(i)}{(i-1)!}=\frac{2^{C_i^2}}{(i-1)!}$$-\sum_{j=1}^{i-1}\frac{F(j)}{(j-1)!}$ $\times\frac{2^{C_{i-j}^2}}{(i-j)!}$（剩下的$(i-j)!$和$(j-1)!$刚好每人分一个）

设$A(x)=\frac{F(i)}{(i-1)!},B(x)=\frac{2^{C_{i}^2}}{(i-1)!},C(x)=\frac{2^{C_{i}^2}}{i!}$

推导这里发现有个致命的错误，$\sum _{j=1}^{i-1}$无法解决，必须重新构造式子。

把后面一坨扔到前面去，左边部分变成$F(i)+\sum_{j=1}^{i-1} F(j) \times 2^{C_{i-j}^2} \times C_{i-1}^{j-1}$。

注意到$j=i$时，$2^{C_{i-j}^2}=2^0=1$，$C_{i-1}^{j-1}=1$。

于是可以把他们两个合并起来，变成$\sum_{j=1}^iF(j)\times 2^{C_{i-j}^2} \times C_{i-1}^{j-1}$。

等价于$A(x)B(x)=C(x)$。

于是得到$A(x)=C(x) B(x)^{-1}$。

可以使用多项式求逆解决。

别忘了$A(x)=\frac {F(i)}{(i-1)!}$，所以答案要乘$(i-1)!$。

代码：

#include <bits/stdc++.h>
#define MAXN 2000005
#define MOD 1004535809
#define invG 334845270
#define G 3
#define int long long
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
inline int ksm(int b,int k){
	int ans=1;
	while (k){
		if (k&1) ans=(1ll*ans*b)%MOD;
		b=(1ll*b*b)%MOD;
		k>>=1;
	}
	return ans;
}
inline int get_inv(int x){
	return ksm(x,MOD-2);
}
int r[MAXN],C[MAXN];
inline void NTT(int *A,int n,int type){
    for (register int i=0;i<n;++i) if (i<r[i]) swap(A[i],A[r[i]]);
    for (register int i=1;i<n;i<<=1){
        int R=i<<1;
        int Gn=ksm(type==1?G:invG,(MOD-1)/R);
        for (register int j=0;j<n;j+=R){
        	int g=1;
            for (register int k=0;k<i;++k,g=(1ll*g*Gn)%MOD){
                int x=A[j+k],y=(1ll*g*A[i+j+k])%MOD;
                A[j+k]=(x+y)%MOD,A[i+j+k]=(x-y+MOD)%MOD;
            }
        }
    }
    if (type==1) return ;
    int inv=get_inv(n);
    for (register int i=0;i<n;++i){
    	A[i]=1ll*A[i]*inv%MOD;
	}
}
int m,L;
inline void InitNTT(int len){
	m=1,L=0;
	while (m<2*len) m<<=1,L++;
	for (register int i=0;i<m;++i){
		r[i]=(r[i>>1]>>1|((i&1)<<(L-1)));
	}
}
inline void Inv(int *A,int *B,int len){
	if (len==1){
		B[0]=get_inv(A[0]);
		return ;
	}
	Inv(A,B,(len+1)>>1);
	InitNTT(len);
	for (register int i=0;i<len;++i) C[i]=A[i];
	for (register int i=len;i<m;++i) C[i]=0;
	NTT(C,m,1),NTT(B,m,1);
	for (register int i=0;i<m;++i){
		B[i]=((2ll-1ll*B[i]*C[i]%MOD+MOD)*B[i]%MOD+MOD)%MOD;
	}
	NTT(B,m,-1);
	for (register int i=len;i<m;++i) B[i]=0;
}
int F[MAXN];
int A[MAXN],B[MAXN],Ans[MAXN];
int fac[MAXN],inv_fac[MAXN],n;
int inv2=ksm(2,MOD-2);
//F=A*B^-1
inline int Calc(int x){
	return 1ll*x*(x-1)/2;//不能取模，要取也只能是MOD-1
}
inline void Init(){
	fac[0]=1;
	for (register int i=1;i<=n;++i) fac[i]=1ll*fac[i-1]*i%MOD;
	for (register int i=0;i<=n;++i) inv_fac[i]=ksm(fac[i],MOD-2);
}
#undef int
int main(){
#define int long long
	n=read();
	Init();
	for (register int i=1;i<=n;++i){
		A[i]=1ll*ksm(2,Calc(i))*inv_fac[i-1]%MOD;
	}
	for (register int i=0;i<=n;++i){
		B[i]=1ll*ksm(2,Calc(i))*inv_fac[i]%MOD;
	}
	InitNTT(n);
	Inv(B,Ans,m);
    
	InitNTT(n);
	NTT(A,m,1);NTT(Ans,m,1);
	for (register int i=0;i<m;++i) A[i]=1ll*A[i]*Ans[i]%MOD;
	NTT(A,m,-1);
    
	printf("%lld\n",1ll*A[n]*fac[n-1]%MOD);
}