T1 数数

解题思路

大概是一个签到题的感觉。。。（但是 pyt 并没有签上）

第一题当然可以找规律，但是咱们还是老老实实搞正解吧。。。

先从小到大拍个序，这样可以保证 \(a_l<a_r\) 直接去掉绝对值。

然后就可以推出如下柿子：

\[\displaystyle\sum_{l=1}^{k}-a_l\times(k-l)+\sum_{r=2}^{k}a_r\times a_r(r-1) \]

\[\displaystyle\sum_{i=1}^{k}a_i\times (2\times i-k-1) \]

然后就会发现 \(a_i\) 的贡献的正负与下标有关系那么对于 \(i<\dfrac{k+1}{2}\) 尽量选择小的数字。

同样的，对于 \(i>\dfrac{k+1}{2}\) 尽量选择比较大的数字。

对于不同的 \(k\) 每一个 \(a_i\) 的系数都是会发生变化的，简单处理一下就好了。

code

#include<bits/stdc++.h>
#define int long long
#define ull unsigned long long
#define f() cout<<"Pass"<<endl
using namespace std;
inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
	return x*f;
}
const int N=3e5+10;
int n,l,r,sum1,sum2,pre[N],s[N];
signed main()
{
	n=read();
	for(int i=1;i<=n;i++)
		s[i]=read();
	l=0;	r=n+1;
	sort(s+1,s+n+1);
	for(int i=1;i<=n;i++)
		pre[i]=pre[i-1]+s[i];
	for(int k=1;k<=n;k++)
	{
		int pos=(k+1)/2;
		sum1-=pre[l];	sum2+=pre[n]-pre[r-1];
		while(l<pos)	l++,sum1+=s[l]*(2*l-k-1);
		while(n-r+1<pos)	r--,sum2+=s[r]*(2*(-n+r)+k-1);
		printf("%lld\n",sum2+sum1);
	}
	return 0;
}

T2 数树

解题思路

树上背包 DP 。

\(f_{i,j,0/1/2/3}\) 表示 节点 \(i\) 目前至少有 \(j\) 条不合法的边，并且当前节点状态是：没有出入边，有一条出边，有一条入边，有一条出边一条入边。

然后进行树形 DP 子树合并计算出叶子节点对于自身的贡献，当然也要把没有贡献的继承过来。

最后算出来的结果运用一个类似于二项式反演的东西就可以得到恰好没有不合法边的状态。

为什么说是类似呢，它的系数是有一些差别的 \((n-i)!\) ，毕竟对于有 \(i\) 条不合法的边而言，它所链接的两个点其实可以看作是一个点，然后就是一个数值的排问题了。

code

#include<bits/stdc++.h>
#define int long long
#define ull unsigned long long
#define f() cout<<"Pass"<<endl
using namespace std;
inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
	return x*f;
}
const int N=5e3+10,mod=998244353;
int n,ans,fac[N],siz[N],f[N][N][4],g[N][4];
int tot,head[N],nxt[N<<1],edge[N<<1],ver[N<<1];
void add_edge(int x,int y,int val)
{
	ver[++tot]=y;
	nxt[tot]=head[x];
	edge[tot]=val;
	head[x]=tot;
}
void dfs(int x)
{
	siz[x]=1;	f[x][0][0]=1;
	for(int i=head[x];i;i=nxt[i])
	{
		int to=ver[i];
		if(siz[to])	continue;
		dfs(to);
		memset(g,0,sizeof(g));
		for(int j=0;j<siz[x];j++)
			for(int k=0;k<siz[to];k++)
			{
				int cnt=(f[to][k][0]+f[to][k][1]+f[to][k][2]+f[to][k][3])%mod;
				switch(edge[i])
				{
					case 1:
						(g[j+k+1][1]+=f[x][j][0]*(f[to][k][0]+f[to][k][1]))%=mod;
						(g[j+k+1][3]+=f[x][j][2]*(f[to][k][0]+f[to][k][1]))%=mod;
						break;
					case 0:
						(g[j+k+1][2]+=f[x][j][0]*(f[to][k][0]+f[to][k][2]))%=mod;
						(g[j+k+1][3]+=f[x][j][1]*(f[to][k][0]+f[to][k][2]))%=mod;
						break;
				}
				(g[j+k][0]+=cnt*f[x][j][0])%=mod;
				(g[j+k][1]+=cnt*f[x][j][1])%=mod;
				(g[j+k][2]+=cnt*f[x][j][2])%=mod;
				(g[j+k][3]+=cnt*f[x][j][3])%=mod;
			}
		siz[x]+=siz[to];
		for(int j=0;j<siz[x];j++)
		{
			f[x][j][0]=g[j][0];
			f[x][j][1]=g[j][1];
			f[x][j][2]=g[j][2];
			f[x][j][3]=g[j][3];
		}
	}
}
signed main()
{
	n=read();
	for(int i=1,x,y;i<n;i++)
	{
		x=read();	y=read();
		add_edge(x,y,1);	add_edge(y,x,0);
	}
	dfs(1);	fac[0]=1;
	for(int i=1;i<=n;i++)
		fac[i]=fac[i-1]*i%mod;
	for(int i=0,temp;i<n;i++)
	{
		temp=0;
		(temp+=f[1][i][0])%=mod;
		(temp+=f[1][i][1])%=mod;
		(temp+=f[1][i][2])%=mod;
		(temp+=f[1][i][3])%=mod;
		if(i&1)	(ans+=mod-fac[n-i]*temp%mod)%=mod;
		else	(ans+=fac[n-i]*temp%mod)%=mod;
	}
	printf("%lld",ans);
	return 0;
}

T3 鼠树

解题思路

其实题写的挺艰辛的。。

考场上是想到了一个两颗线段树维护（一棵维护归属点，一棵维护权值）的办法，但是貌似单次修改的复杂度是 \(nlog^2n\) 的，还不如暴力。。

最主要的是它的 3 操作还是有问题的。。（\(code\)）

正解的做法就比较神仙了。

开一个 set 维护单个点的归属点，具体实现主要结合树链剖分，维护每一条链最顶端的点 set 并且记录该 set 里的深度最小值，与目前的点的深度相比较。

时间复杂度大概是 \(log\;n\) ，这里的 set 是按照深度由小到大排的序。

还有两棵线段树，一个维护黑色节点在它的所有管辖点应该下放的权值还有范围以及权值和，另一个维护因为节点操作的缘故，而出现的比较杂碎的权值。

第二个的话，其实就是区间修改，区间查询的线段树，也可以用树状数组来实现。

为了方便下文将会把第一颗线段树称为 T1 ，第二颗称为 T2 。

实现的话分操作讲一下吧。。

• 1 操作除了需要查询归属点应该下放的权值外也要计算一下 T2 里面琐碎的权值。

• 2 操作直接在 T1 里单点修改权值就好了。

• 3 操作查询 T1 子树范围内的管辖点应下放的权值与范围的乘积，也要算上计算 T2 子树范围内的权值和，还有就是对于子树根节点向下一部分的点，他们的管辖点可能是在子树之外的，这里也需要算进去。

• 4 操作直接给 T1 区间修改就好了。

• 5 操作就开始有一点恶心人了，先是查找更改之前当前节点（计为 \(x\) ）的归属点（计为 \(att\)），将现在应该加到 \(x\) 上的范围减去，然后将范围加入到 \(x\) 上，对于之前的下放权值继承到 \(x\) 上。

• 6操作与 5 操作有一些类似，同样是范围的加减继承，同样的把相对于 \(att\) 多的权值区间修改到 T2 上，这也就是维护两颗线段树的意义所在。

code

#include<bits/stdc++.h>
#define ui unsigned int
#define ull unsigned long long
#define f() cout<<"Pass"<<endl
#define ls x<<1
#define rs x<<1|1
using namespace std;
inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
	return x*f;
}
const int N=1e6+10,INF=1e9;
int n,m,minn[N];
int tot,head[N],nxt[N<<1],ver[N<<1];
int tim,dfn[N],siz[N],son[N],dep[N],fa[N],topp[N];
struct Sort{bool operator ()(int x,int y){return dep[x]<dep[y];}};
set<int,Sort> s[N];
struct Segment_Tree1
{
	struct Node
	{
		ui val,ran,dat;
	}tre[N<<2];
	void push_down(int x)
	{
		if(!tre[x].val)	return ;
		if(tre[ls].ran)
		{
			tre[ls].val+=tre[x].val;
			tre[ls].dat+=tre[x].val*tre[ls].ran;
		}
		if(tre[rs].ran)
		{
			tre[rs].val+=tre[x].val;
			tre[rs].dat+=tre[x].val*1tre[rs].ran;
		}
		tre[x].val=0;
	}
	void push_up(int x)
	{
		tre[x].ran=tre[ls].ran+tre[rs].ran;
		tre[x].dat=tre[ls].dat+tre[rs].dat;
	}
	ui query_val(int x,int l,int r,int pos)
	{
		if(l==r)	return tre[x].val;
		push_down(x);
		int mid=(l+r)>>1;	ui sum=0;
		if(pos<=mid)	sum=query_val(ls,l,mid,pos);
		else	sum=query_val(rs,mid+1,r,pos);
		push_up(x);
		return sum;
	}
	ui query_dat(int x,int l,int r,int L,int R)
	{
		if(L<=l&&r<=R)	return tre[x].dat;
		push_down(x);
		int mid=(l+r)>>1;	ui sum=0;
		if(L<=mid)	sum+=query_dat(ls,l,mid,L,R);
		if(R>mid)	sum+=query_dat(rs,mid+1,r,L,R);
		push_up(x);
		return sum;
	}
	int query_ran(int x,int l,int r,int L,int R)
	{
		if(L<=l&&r<=R)	return tre[x].ran;
		push_down(x);
		int mid=(l+r)>>1,sum=0;
		if(L<=mid)	sum+=query_ran(ls,l,mid,L,R);
		if(R>mid)	sum+=query_ran(rs,mid+1,r,L,R);
		push_up(x);
		return sum;
	}
	void insert_val(int x,int l,int r,int L,int R,ui num)
	{
		if(L<=l&&r<=R)
		{
			if(!tre[x].ran)	return;
			tre[x].val+=num;
			tre[x].dat+=num*tre[x].ran;
			return ;
		}
		push_down(x);
		int mid=(l+r)>>1;
		if(L<=mid)	insert_val(ls,l,mid,L,R,num);
		if(R>mid)	insert_val(rs,mid+1,r,L,R,num);
		push_up(x);
	}
	void insert_ran(int x,int l,int r,int pos,ui num)
	{
		if(l==r)
		{
			tre[x].ran+=num;
			if(!tre[x].ran)	tre[x].val=0;
			tre[x].dat=tre[x].val*tre[x].ran;
			return ;
		}
		push_down(x);
		int mid=(l+r)>>1;
		if(pos<=mid)	insert_ran(ls,l,mid,pos,num);
		else	insert_ran(rs,mid+1,r,pos,num);
		push_up(x);
	}
}t1;
struct Segment_Tree2
{
	struct Node
	{
		ui dat,laz;
	}tre[N<<1];
	void push_down(int x,int l,int r)
	{
		if(!tre[x].laz)	return ;
		int mid=(l+r)>>1;
		tre[ls].laz+=tre[x].laz;	tre[rs].laz+=tre[x].laz;
		tre[ls].dat+=(mid-l+1)*tre[x].laz;
		tre[rs].dat+=(r-mid)*tre[x].laz;
		tre[x].laz=0;
	}
	void push_up(int x)
	{
		tre[x].dat=tre[ls].dat+tre[rs].dat;
	}
	void insert(int x,int l,int r,int L,int R,ui num)
	{
		if(L<=l&&r<=R)
		{
			tre[x].dat+=num*(r-l+1);
			tre[x].laz+=num;
			return ;
		}
		push_down(x,l,r);
		int mid=(l+r)>>1;
		if(L<=mid)	insert(ls,l,mid,L,R,num);
		if(R>mid)	insert(rs,mid+1,r,L,R,num);
		push_up(x);
	}
	ui query(int x,int l,int r,int L,int R)
	{
		if(L<=l&&r<=R)	return tre[x].dat;
		push_down(x,l,r);
		int mid=(l+r)>>1;	ui sum=0;
		if(L<=mid)	sum+=query(ls,l,mid,L,R);
		if(R>mid)	sum+=query(rs,mid+1,r,L,R);
		push_up(x);
		return sum;
	}
}t2;
void add_edge(int x,int y)
{
	ver[++tot]=y;
	nxt[tot]=head[x];
	head[x]=tot;
}
void dfs1(int x)
{
	siz[x]=1;
	dfn[x]=++tim;
	for(int i=head[x];i;i=nxt[i])
	{
		int to=ver[i];
		fa[to]=x;	dep[to]=dep[x]+1;
		dfs1(to);
		siz[x]+=siz[to];
		if(siz[to]>siz[son[x]])
			son[x]=to;
	}
}
void dfs2(int x,int tp)
{
	topp[x]=tp;
	if(son[x])	dfs2(son[x],tp);
	for(int i=head[x];i;i=nxt[i])
		if(ver[i]!=son[x])
			dfs2(ver[i],ver[i]);
}
int find_att(int x)
{
	while(x)
	{
		if(minn[topp[x]]<=dep[x])
		{
			auto pos=s[topp[x]].upper_bound(x);	pos--;
			return (*pos);
		}
		x=fa[topp[x]];
	}
}
void update_min(int x)
{
	minn[x]=(s[x].size()?dep[*(s[x].begin())]:INF);
}
signed main()
{
	n=read();	m=read();
	for(int i=2,x;i<=n;i++)
		x=read(),add_edge(x,i);
	dfs1(1);	dfs2(1,1);
	memset(minn,0x7f,sizeof(minn));
	s[1].insert(1);	update_min(1);
	t1.insert_ran(1,1,n,dfn[1],siz[1]);
	while(m--)
	{
		int opt,x,val,att;
		opt=read();	x=read();
		if(opt==2||opt==4)	val=read();
		if(opt==1||opt==3||opt==5)	att=find_att(x);
		if(opt==6)	att=find_att(fa[x]);
		if(opt==1)	printf("%u\n",t1.query_val(1,1,n,dfn[att])+t2.query(1,1,n,dfn[x],dfn[x]));
		if(opt==2)	t1.insert_val(1,1,n,dfn[x],dfn[x],val);
		if(opt==3)
		{
			int att=find_att(x);
			ui ran=siz[x]-t1.query_ran(1,1,n,dfn[x],dfn[x]+siz[x]-1);
			ui sum=t2.query(1,1,n,dfn[x],dfn[x]+siz[x]-1);
			sum+=t1.query_dat(1,1,n,dfn[x],dfn[x]+siz[x]-1);
			sum+=t1.query_val(1,1,n,dfn[att])*ran;
			printf("%u\n",sum);
		}
		if(opt==4)	t1.insert_val(1,1,n,dfn[x],dfn[x]+siz[x]-1,val);
		if(opt==5)
		{
			int att=find_att(x);
			ui ran=siz[x]-t1.query_ran(1,1,n,dfn[x],dfn[x]+siz[x]-1);
			ui val=t1.query_val(1,1,n,dfn[att]);
			t1.insert_ran(1,1,n,dfn[att],-ran);
			t1.insert_ran(1,1,n,dfn[x],ran);
			t1.insert_val(1,1,n,dfn[x],dfn[x],val);
			s[topp[x]].insert(x);	update_min(topp[x]);
		}
		if(opt==6)
		{
			int att=find_att(fa[x]);
			ui ran=t1.query_ran(1,1,n,dfn[x],dfn[x]);
			ui val=t1.query_val(1,1,n,dfn[x]);
			t1.insert_ran(1,1,n,dfn[att],ran);
			t1.insert_ran(1,1,n,dfn[x],-ran);
			val-=t1.query_val(1,1,n,dfn[att]);
			t2.insert(1,1,n,dfn[x],dfn[x]+siz[x]-1,val);
			t1.insert_val(1,1,n,dfn[x],dfn[x]+siz[x]-1,-val);
			s[topp[x]].erase(x);	update_min(topp[x]);
		}
	}
	return 0;
}