Codeforces Round #722 (Div. 1)

A. Parsa's Humongous Tree

题目描述

点此看题

给一棵树，试确定 \(a_i\in[l_i,r_i]\) 使得 \(\sum |a_u-a_v|\) 最大，其中 \((u,v)\) 在原树上有边连接。

解法

这道题我先猜了一个结论，\(a_i=l_i\or a_i=r_i\)

证明好像并不难，使用调整法，如果 \(a_i\not=l_i\and a_i\not=r_i\)，那么调整到 \(l_i\) 或 \(r_i\) 不会使答案变得更差。

然后搞个树 \(dp\) 即可，时间复杂度 \(O(n)\)

#include <cstdio>
#include <iostream>
using namespace std;
const int M = 100005;
#define int long long
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int T,n,tot,f[M],l[M],r[M],dp[M][2];
struct edge
{
	int v,next;
}e[2*M];
int Abs(int x) {return x>0?x:-x;}
void dfs(int u,int fa)
{
	for(int i=f[u];i;i=e[i].next)
	{
		int v=e[i].v;
		if(v==fa) continue;
		dfs(v,u);
		dp[u][0]+=max(dp[v][0]+Abs(l[u]-l[v]),dp[v][1]+Abs(l[u]-r[v]));
		dp[u][1]+=max(dp[v][1]+Abs(r[u]-r[v]),dp[v][0]+Abs(r[u]-l[v]));
	}
}
void work()
{
	n=read();tot=0;
	for(int i=1;i<=n;i++)
	{
		l[i]=read();r[i]=read();
		dp[i][0]=dp[i][1]=f[i]=0;
	}
	for(int i=1;i<n;i++)
	{
		int u=read(),v=read();
		e[++tot]=edge{v,f[u]},f[u]=tot;
		e[++tot]=edge{u,f[v]},f[v]=tot;
	}
	dfs(1,0);
	printf("%lld\n",max(dp[1][0],dp[1][1]));
}
signed main()
{
	T=read();
	while(T--) work();
}

B. Kavi on Pairing Duty

题目描述

点此看题

\(2n\) 个点排列在 \(x\) 轴上，第 \(i\) 个点的坐标是 \(i\)，把这 \(2n\) 个点划分成 \(n\) 对，问满足下列条件的划分数量：

对于任意点对 \(A,B\)，连成的线段要不然长度一样，要不然存在包含关系。

\(1\leq n\leq 10^6\)

解法

设 \(dp[n]\) 为有 \(2n\) 个点的划分方案数，考虑一小步的转移，我们选择长度为 \(i\) 的点对连成线段，因为它们不存在包含关系，所以只有在它们交叉的部分会形成子问题，我们来讨论两种情况：

  • 如果 \(i\geq n\)，那么在当前问题只有一种划分方案，但是递归下去会形成所有 \(x<n\) 的子问题，所以这时候用 \(\sum_{i=0}^{n-1} dp[i]\) 加上去即可。
  • 如果 \(i<n\)，那么没有递归子问题，必须统计出所有线段没有公共部分的方案，这等价于把 \(2n\) 划分成若干个连续段，每个连续段长度为偶数，设 \(f[i]\) 为 \(i\) 偶数真因数个数，那么把 \(f[2n]\) 加上去即可，这个很容易预处理。

时间复杂度 \(O(n\log n)\)

#include <cstdio>
const int MOD = 998244353;
const int M = 2000005;
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int n,f[M],dp[M];
void init(int n)
{
	for(int i=2;i<=n;i+=2)
		for(int j=2*i;j<=n;j+=i)
			f[j]++;
}
signed main()
{
	init(2e6);
	n=read();
	for(int i=1,s=1;i<=n;i++)
	{
		dp[i]=(s+f[2*i])%MOD;
		s=(s+dp[i])%MOD;
	}
	printf("%d\n",dp[n]);
}

C. Trees of Tranquillity

题目描述

给定两棵以 \(1\) 为根 \(n\) 个点的树，建一个新图，如果满足下列条件的 \((u,v)\) 就连边：

  • 在第一棵树中 \(u,v\) 存在祖先\(-\)子代关系。
  • 在第二棵树中 \(u,v\) 不存在祖先\(-\)子代关系。

求这个新建图最大团，即一个集合满足任意两点都有直接边相连。

\(2\leq n\leq 3\cdot 10^5\)

解法1

首先观察到一个比较重要的性质：选出来的点在第一棵树上构成一条链（虽然可能会中断）。

那么就先考虑一个简化的问题，如果只有第一棵树是一条链我们怎么做？

\(dp\) 是不好 \(dp\) 的，换一种方法吧。可以把这条链上的点在第二棵树上标记出来，然后每次加入一个点就考虑贪心地优化答案，如果这个点的祖先有被选的，用它替换祖先是更优的；如果这个点的子代有被选的，这个点就不会存在答案中；否则直接把这个点选上去。

判断祖先和子代有无被选点可以用 \(\tt dfs\) 序\(+\)线段树完成，考虑扩展到普通的树，其实就是在访问到某个点的时候在第二棵树上考虑这个点，回溯的时候撤回操作，这样访问到每个点的时候维护的都是从根到它一条链的情况了。

时间复杂度 \(O(n\log n)\)

#include <cstdio>
#include <vector>
using namespace std;
const int M = 300005;
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int T,n,Ind,now,ans,l[M],r[M],s[4*M],tag[4*M],tr[4*M];
vector<int> g1[M],g2[M];
void pre(int u,int fa)
{
	l[u]=++Ind;
	for(int i=0;i<g2[u].size();i++)
	{
		int v=g2[u][i];
		if(v==fa) continue;
		pre(v,u);
	}
	r[u]=Ind;
}
void down(int i)
{
	if(tag[i]==-1) return ;
	tr[i<<1]=tr[i<<1|1]=tag[i<<1]=tag[i<<1|1]=tag[i];
	tag[i]=-1;
}
void add1(int i,int l,int r,int id,int x)//add a tag to a certain point
{
	if(l==r) {s[i]+=x;return ;}
	int mid=(l+r)>>1;
	if(id<=mid) add1(i<<1,l,mid,id,x);
	else add1(i<<1|1,mid+1,r,id,x);
	s[i]=s[i<<1]+s[i<<1|1]; 
}
int ask1(int i,int l,int r,int L,int R)//ask the tag in subtree
{
	if(L<=l && r<=R) return s[i];
	if(L>r || l>R) return 0;
	int mid=(l+r)>>1;
	return ask1(i<<1,l,mid,L,R)+ask1(i<<1|1,mid+1,r,L,R); 
}
void add2(int i,int l,int r,int L,int R,int x)//update the subtree
{
	if(L<=l && r<=R) {tr[i]=tag[i]=x;return ;}
	if(L>r || l>R) return ;
	int mid=(l+r)>>1;down(i);
	add2(i<<1,l,mid,L,R,x);
	add2(i<<1|1,mid+1,r,L,R,x);
}
int ask2(int i,int l,int r,int id)
{
	if(l==r) return tr[i];
	int mid=(l+r)>>1;down(i);
	if(mid>=id) return ask2(i<<1,l,mid,id);
	return ask2(i<<1|1,mid+1,r,id);
}
void dfs(int u,int fa)
{
	int t1=ask1(1,1,n,l[u],r[u]),t2=ask2(1,1,n,l[u]);
	if(!t1)
	{
		if(!t2) now++;
		add1(1,1,n,l[u],1);
		if(t2) add2(1,1,n,l[t2],r[t2],0);
		add2(1,1,n,l[u],r[u],u);
	}
	ans=max(ans,now);
	for(int i=0;i<g1[u].size();i++)
	{
		int v=g1[u][i];
		if(v==fa) continue;
		dfs(v,u);
	}
	if(!t1)//call back the operation
	{
		if(!t2) now--;
		add1(1,1,n,l[u],-1);
		add2(1,1,n,l[u],r[u],0);
		if(t2) add2(1,1,n,l[t2],r[t2],t2);
	}
}
signed main()
{
	T=read();
	while(T--)
	{
		n=read();Ind=now=ans=0;
		for(int i=1;i<=n;i++)
			g1[i].clear(),g2[i].clear();
		for(int i=1;i<=4*n;i++)
			s[i]=tr[i]=0,tag[i]=-1;
		for(int i=2;i<=n;i++)
		{
			int j=read();;
			g1[i].push_back(j);
			g1[j].push_back(i);
		}
		for(int i=2;i<=n;i++)
		{
			int j=read();
			g2[i].push_back(j);
			g2[j].push_back(i);
		}
		pre(1,0);
		dfs(1,0);
		printf("%d\n",ans);
	}
}

解法2

\(\tt xjx\) 给了一种更简洁的方法，也就是选出的点在第二棵树上满足 \([l_i,r_i]\) 不交，其中 \(l_i,r_i\) 分别代表子树欧拉序的左右端点。

然后还是在第一棵树上 \(\tt dfs\)，由于欧拉序区间只存在包含或者不交的关系，他用维护了所有的线段，如果有包含它的线段那么就可以贪心替换，如果没有区间和它有交那么可以直接插入，用 \(\tt set,map\) 都可以维护。

#include<cstdio>//JZM YYDS!!!
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#define ll long long
#define MAXN 300005
#define uns unsigned
#define MOD 998244353ll
#define INF 0x3f3f3f3f
using namespace std;
inline ll read(){
	ll x=0;bool f=1;char s=getchar();
	while((s<'0'||s>'9')&&s>0){if(s=='-')f^=1;s=getchar();}
	while(s>='0'&&s<='9')x=(x<<1)+(x<<3)+s-'0',s=getchar();
	return f?x:-x;
}
int n,IN;
int bg[MAXN],ed[MAXN],ans;
vector<int>G[MAXN],G_[MAXN];
struct node{
	int x,y;node(){}
	node(int X,int Y){x=X,y=Y;}
	bool operator<(const node&b)const{
		if(b.x!=x)return x<b.x;
		else return y>b.y;
	}
};
map<node,bool>mp;
map<node,bool>::iterator it;
inline void dfs_(int x){
	bg[x]=++IN;
	for(uns i=0;i<G_[x].size();i++)dfs_(G_[x][i]);
	ed[x]=IN;
}
inline void dfs(int x){
	node cg=node(0,0);
	bool ok=1;
	mp[node(bg[x],bg[x])],it=mp.find(node(bg[x],bg[x]));
	if(it!=mp.begin()){
		it--;
		if(it->first.y>=bg[x])cg=it->first;
		it++;
	}
	it++;
	if(it!=mp.end()&&it->first.x<=ed[x])ok=0;
	mp.erase(node(bg[x],bg[x]));
	if(ok){
		if(cg.x)mp.erase(cg);
		mp[node(bg[x],ed[x])];
	}
	ans=max(ans,(int)mp.size());
	for(uns i=0;i<G[x].size();i++)dfs(G[x][i]);
	if(ok){
		if(cg.x)mp[cg];
		mp.erase(node(bg[x],ed[x]));
	}
}
signed main()
{
	for(int T=read();T--;){
		n=read(),IN=0,ans=1;
		for(int i=1;i<=n;i++)
			G[i].clear(),G_[i].clear(),bg[i]=ed[i]=0;
		for(int i=2;i<=n;i++)G[read()].push_back(i);
		for(int i=2;i<=n;i++)G_[read()].push_back(i);
		mp.clear();
		dfs_(1),dfs(1);
		printf("%d\n",ans);
	}
	return 0;
}

D. It's a bird! No, it's a plane! No, it's AaParsa!

题目描述

点此看题

给定 \(n\) 个点 \(m\) 条边的有向图，在第 \(s\) 秒第 \(i\) 条边的终点会变为 \((b_i+s)\%n\)，问所有点对的最短路。

\(2\leq n\leq 600,m\leq n^2\)

解法

这道题最重要的就是不能把时间放进最短路的状态里面，有一个重要的提示：Note that AaParsa can stay in a city for as long as he wants，也就是说我们只需要用到每个点的最短路去扩展即可。

对于那么现在的问题是计算边权了，设到 \(u\) 的最短路是 \(d\)，则让边 \(i\) 指向 \(v\) 的实际边权是：

\(e[i].c+cal((e[i].u+d)\%n,v)\)

其中 \(cal(x,y)\) 是 \(x\) 转到 \(y\) 的最小时间，那么每次扩展时扫两边就可以计算实际边权，跑 \(n\) 次 \(\tt dijkstra\) 的复杂度是 \(O(n^3)\) 的，这道题不加堆优化好像要快一些，但是我还是卡过去了。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
const int M = 605;
#define int long long
const int inf = 0x3f3f3f3f3f3f3f3f;
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int n,m,tot,f[M],a[M],dis[M],vis[M];
struct edge
{
	int v,c,next;
}e[M*M];
struct node
{
	int u,c;
	bool operator < (const node &r) const
	{
		return c>r.c;
	}
};
void work(int s)
{
	memset(dis,0x3f,sizeof dis);
	memset(vis,0,sizeof vis);
	priority_queue<node> q;
	dis[s]=0;q.push(node{s,0});
	while(!q.empty())
	{
		int u=q.top().u,d=q.top().c;q.pop();
		if(vis[u]) continue;vis[u]=1;
		for(int i=0;i<n;i++) a[i]=inf;
		for(int i=f[u];i;i=e[i].next)
		{
			int v=e[i].v;
			a[(v+d)%n]=e[i].c;
		}
		for(int i=0,mi=inf;i<n;i++)
		{
			mi=min(mi,a[i]-i);
			if(dis[i]>d+mi+i)
			{
				dis[i]=d+mi+i;
				q.push(node{i,dis[i]});
			}
		}
		for(int i=n-1,mi=inf;i>=1;i--)
		{
			mi=min(mi,a[i]+n-i);
			int j=i-1;
			if(dis[j]>d+mi+j)
			{
				dis[j]=d+mi+j;
				q.push(node{j,dis[j]});
			}
		}
	}
}
signed main()
{
	n=read();m=read();
	for(int i=1;i<=m;i++)
	{
		int u=read(),v=read(),c=read();
		e[++tot]=edge{v,c,f[u]},f[u]=tot;
	}
	for(int i=0;i<n;i++,puts(""))
	{
		work(i);
		for(int j=0;j<n;j++)
			printf("%lld ",dis[j]);
	}
}

E. Mashtali and Hagh Trees

题目描述

点此看题

称一棵有向树为阿七树当且仅当满足如下条件：

  • 这棵树的最长有向路径是长度 \(n\)
  • 以点任意点 \(u\) 为端点的有向边不超过 \(3\) 条
  • \(u,v\) 是朋友当且仅当 \(u\) 能到 \(v\) 或者 \(v\) 能到 \(u\)，树上任意两点要么是朋友要么有一个共同的朋友。

给定 \(n\)，问不同构的阿七树有多少个，答案模 \(998244353\)

\(1\leq n\leq 10^6\)

解法

这道题最好不要直接从有向树的角度入手，我们可以把树分层，有向边的起点划分在上层，终点划分在下层。

在这个分层图上考虑 \(u,v\) 是朋友的条件，发现总有一个根，满足它和上层能构成一棵树，它和下层也能构成一棵有向树。考虑最长有向路径长度是 \(n\) 的条件，就等价于这个分层图的高度是 \(n\)

那么我们确定根上面的树和根下面的树再用乘法原理即可，设 \(dp(i,j)\) 表示高度为 \(i\) 的树根节点度数是 \(j\) 的方案数，我们用最上面的根来统计某一棵树的答案，所以要强制上面树的深度为 \(2\)，上面树为空要特殊讨论，所以可以写出答案：

\[\sum_{i=0}^3 dp(n,i)+\sum_{i=1}^n\sum_{j=2}^3\sum_{k=0}^{3-j}dp(i,j)\times dp(n-i,k) \]

现在的问题变成了算 \(dp(i,j)\)，可以定义 \(f(i,j)\) 表示高度至少为 \(i\) 的树根节点度数是 \(j\) 的方案数，这个要好转移一些，假设子树一共有 \(x\) 中选法，那么相当于从中选出 \(j\) 个来组成这个树，由于要考虑同构问题我们对于相同的子树种类是不存在顺序的，这相当于 \(x\) 个非负整数的和为 \(j\)，方案数是 \({x+j-1\choose j}\)，至于 \(x\) 就是 \(\sum_{j=0}^2 f(i-1,j)\)，最后再差分回来即可。

时间复杂度 \(O(n)\)

#include <cstdio>
const int M = 1000005;
const int MOD = 998244353;
#define int long long
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int n,ans,dp[M][4],inv[4]={0,1,(MOD+1)/2,(MOD+1)/3};
int C(int n,int m)
{
	int r=1;
	if(n<m) return 0;
	for(int i=0;i<m;i++) r=r*(n-i)%MOD;
	for(int i=1;i<=m;i++) r=r*inv[i]%MOD;
	return r;
}
signed main()
{
	n=read();dp[0][0]=1;
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<=3;j++)
		{
			int x=0;
			for(int k=0;k<=2;k++)
				x=(x+dp[i-1][k])%MOD;
			dp[i][j]=C(x+j-1,j);
		}
	}
	for(int i=n;i>=1;i--)
		for(int j=0;j<=3;j++)
			dp[i][j]=(dp[i][j]-dp[i-1][j]+MOD)%MOD;
	for(int i=1;i<=n;i++)
		for(int j=2;j<=3;j++)
			for(int k=0;k<=3-j;k++)
				ans=(ans+dp[i][j]*dp[n-i][k])%MOD;
	for(int i=0;i<=3;i++)
		ans=(ans+dp[n][i])%MOD;
	printf("%lld\n",ans);
}

F. AmShZ Farm

题目描述

点此看题

\(a,b\) 都数组由 \([1,n]\) 中的数字组成，\(a\) 数组长度为 \(n\)，并且满足给任意元素加上任意非负数后能变成某个排列，\(b\) 数组长度为 \(k\)，满足 \(a_{b_1}=a_{b_2}=...=a_{b_k}\)（注意我们没有要求 \(a,b\) 数组的元素两两不同）

问有多少个本质不同的数组对 \((a,b)\)，答案取模 \(998244353\)

\(1\leq n\leq10^9,1\leq k\leq 10^5\)

解法

发现 \(a,b\) 两个数组的计数还算比较独立吧，我们先考虑 \(a\) 数组怎么计数。

设 \(c_i\) 为数字 \(i\) 的出现次数，则限制可以翻译为 \(\sum_{j=i}^{n} c_j\leq n-i+1\)，但是这样根本算不出来，因为这个限制牵扯到的东西太多了，我们想要更加独立的限制。

不妨把题目换个说法：我们有 \(n+1\) 个位置排成一排，有 \(n\) 个人要坐进来，第 \(i\) 个人一开始会到位置 \(a_i\)（\(1\leq a_i\leq n\)），如果位置已满就往编号大的位置走，如果最后剩下的位置是 \(n+1\) 的话就是一个合法的 \(a\) 序列。

这是一个经典的序列转等概率环模型（第二次见了），所以我们可以改写题目为：有 \(n+1\) 个位置排成一个环，有 \(n\) 个人要坐进来，第 \(i\) 个人一开始会到位置 \(a_i\)（\(1\leq a_i\leq n+1\)），如果位置已满就往右边走，如果最后剩下的位置是 \(n+1\) 的话就是一个合法的 \(a\) 序列。

因为是一个环并且初始到每个点的概率相同，所以每个点被空出来的概率也是相同的，不难发现方案数就是 \((n+1)^{n-1}\)

我们再深入下去剖析这个模型，对于每种合法的 \(a\) 序列都可以映射到 \(n\) 种不同的不合法序列，因为如果我们让 \(a_i\) 变成 \((a_i+x-1)\%(n+1)+1\)，那么空出的位置 \(t\) 会变成 \((x+t-1)\%(n+1)+1\)，由此引出一个重要的性质：对于这 \(n+1\) 个方案来说，数字的分布情况是不会改变的，所以我们可以统计出所有排列的答案再除以 \(n+1\)

\(a\) 数组差不多搞定了，我们来解决 \(b\) 数组的计数。

枚举数字 \(x\) 的出现次数 \(i\)，由于 \(x\) 有 \(n+1\) 种选择就自动除 \(n+1\)，所以可以写出答案式：

\[\sum_{i=0}^n{n\choose i}\cdot n^{n-i}\cdot i^k \]

首先要观察式子再化简（官方题解不给推导过程差评），因为底数很大但是指数很小，所以使用斯特林反演：

\[n^k=\sum_{i=0}^kS(k,i)\cdot i!\cdot {n\choose i} \]

这个式子最好固定的指数，所以我们把它带进 \(i^k\) 中：

\[\sum_{i=0}^n{n\choose i}\cdot n^{n-i}\sum_{j=0}^kS(k,j)\cdot {i\choose j}\cdot j! \]

这时候心理要有根弦（我要交作业），通常是用组合意义和二项式反演把式子化简的，因为要让 \(i\) 出现得尽量少，所以我们把 \({i\choose j}\) 中的 \(i\) 给换走，那么这可以用一个组合恒等式：

\[{n\choose i}{i\choose j}={n\choose j}{n-j\choose i-j} \]

把这个式子带进去，再调整一下顺序：

\[\sum_{j=0}^kS(k,j)\cdot {n\choose j}\cdot j!\cdot (\sum_{i=j}^n{n-j\choose i-j}\cdot n^{n-i}) \]

要用二项式反演是需要从 \(0\) 开始枚举的，所以我们把 \(i\) 调整成 \(i-j\)：

\[\sum_{j=0}^kS(k,j)\cdot {n\choose j}\cdot j!\cdot (\sum_{i=0}^{n-j}{n-j\choose i}\cdot n^{n-j-i}) \]

这是个明显的二项式反演了，所以可以得到最后的结果。

\[\sum_{j=0}^kS(k,j)\cdot {n\choose j}\cdot j!\cdot(n+1)^{n-j} \]

上面的式子显然可以 \(O(n\log n)\) 算，现在的问题就是快速算第二类斯特林数了，\(S(n,m)\) 的组合意义是 \(n\) 个不同的小球放在 \(m\) 个相同盒子的方案数，要求盒子非空，所以我们容斥空盒子数量：

\[S(n,m)=\frac{1}{m!}\sum_{k=0}^m(-1)^k{m\choose k}(m-k)^n \]

因为盒子是相同的所以要除以盒子的排列 \(\frac{1}{m!}\)，可以通过变形让它可以卷积：

\[S(n,m)=\sum_{k=0}^m\frac{(-1)^k}{k!}\cdot\frac{(m-k)^n}{(m-k)!} \]

随便卷一下就可以做到 \(O(n\log n)\)，所以总时间复杂度 \(O(n\log n)\)

#include <cstdio>
#include <iostream>
using namespace std;
const int M = 300005;
const int MOD = 998244353;
#define int long long
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
namespace poly
{
	int len,A[M],B[M],rev[M];
	int qkpow(int a,int b)
	{
		int r=1;
		while(b>0)
		{
			if(b&1) r=r*a%MOD;
			a=a*a%MOD;
			b>>=1;
		}
		return r;
	}
	void NTT(int *a,int len,int op)
	{
		for(int i=0;i<len;i++)
		{
			rev[i]=(rev[i>>1]>>1)|((len/2)*(i&1));
			if(i<rev[i]) swap(a[i],a[rev[i]]);
		}
		for(int s=2;s<=len;s<<=1)
		{
			int t=s/2,w=(op==1)?qkpow(3,(MOD-1)/s):qkpow(3,MOD-1-(MOD-1)/s);
			for(int i=0;i<len;i+=s)
				for(int j=0,x=1;j<t;j++,x=x*w%MOD)
				{
					int fe=a[i+j],fo=a[i+j+t];
					a[i+j]=(fe+x*fo)%MOD;
					a[i+j+t]=((fe-x*fo)%MOD+MOD)%MOD;
				}
		}
		if(op==1) return ;
		int inv=qkpow(len,MOD-2);
		for(int i=0;i<len;i++) a[i]=a[i]*inv%MOD;
	}
	void work(int n,int m,int *a,int *b,int *c)
	{
		len=1;while(len<n+m) len<<=1;
		for(int i=0;i<len;i++) A[i]=B[i]=0;
		for(int i=0;i<n;i++) A[i]=a[i];
		for(int i=0;i<m;i++) B[i]=b[i];
		NTT(A,len,1);NTT(B,len,1);
		for(int i=0;i<len;i++) A[i]=A[i]*B[i]%MOD;
		NTT(A,len,-1);
		for(int i=0;i<n+m;i++) c[i]=A[i];
	}
}
int n,k,ans,fac[M],inv[M],a[M],b[M],c[M];
void init(int n)
{
	inv[0]=inv[1]=fac[0]=1;
	for(int i=2;i<=n;i++) inv[i]=inv[MOD%i]*(MOD-MOD/i)%MOD;
	for(int i=2;i<=n;i++) inv[i]=inv[i]*inv[i-1]%MOD;
	for(int i=1;i<=n;i++) fac[i]=fac[i-1]*i%MOD;
}
signed main()
{
	init(1e5);
	n=read();k=read();c[0]=1;
	for(int i=0;i<=k;i++)
	{
		a[i]=poly::qkpow(i,k)*inv[i]%MOD;
		b[i]=(i%2)?(MOD-inv[i]):inv[i];
		if(i>0) c[i]=c[i-1]*(n-i+1)%MOD*poly::qkpow(i,MOD-2)%MOD;
	}
	poly::work(k+1,k+1,a,b,a);
	for(int i=0;i<=k;i++)
		ans=(ans+a[i]*c[i]%MOD*poly::qkpow(n+1,n-i)%MOD*fac[i])%MOD;
	printf("%lld\n",ans);
}
posted @ 2021-05-27 17:53  C202044zxy  阅读(363)  评论(0)  编辑  收藏  举报