题解:[CSP-S 2022] 数据传输

题目传送门

题意分析

给定一棵树,点 \(i\) 有权值 \(v_i\),\(q\) 次询问,每次询问一条 \(u\sim v\) 的路径 \(p_1,p_2,\cdots,p_m\),使得 \(\displaystyle\sum_{i=1}^ma_{p_i}\) 最小,求最小值。

点 \(x\) 可以直接跳到与其距离小于等于 \(k\) 的点。

\(n,q\leq2\times10^5\),\(k\leq 3\)。

\(k=1\)

\(k=1\),即 \(u\sim v\) 路径上的 \(a\) 之和。

树上前缀和简单维护。

\(k=2\)

考虑跳了 \(2\) 个节点,跳出了路径,下一步一定也要跳回来。

因此 \(k=2\) 的情况,等价于可以在路径上选择连续跳一步或者两步。

考虑 DP 求解这个东西,因为需要树上路径查询,考虑树剖线段树维护静态 DDP。

打包成矩阵,设 \(f_x\) 表示从底下的某个起点往上跳到 \(x\) 的最小代价,\(y\) 为 \(x\) 的重子节点,\(z\) 为 \(y\) 的重子节点,有:

\[\begin{bmatrix} a_x&a_x\\ 1&0 \end{bmatrix} \begin{bmatrix} f_y\\ f_z \end{bmatrix} = \begin{bmatrix} f_x\\ f_y \end{bmatrix} \]

\((\min,+)\) 矩阵维护。

再考虑从上往下跳到 \(z\),设 \(x\) 为 \(y\) 的父节点,\(y\) 为 \(z\) 的父节点,有:

\[\begin{bmatrix} a_z&a_z\\ 1&0 \end{bmatrix} \begin{bmatrix} f_x\\ f_y \end{bmatrix} = \begin{bmatrix} f_y\\ f_z \end{bmatrix} \]

于是容易线段树维护。需要特判 \(\operatorname{lca}(u,v)\)。

期望得分 56pts。

参考代码
//#include<bits/stdc++.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<iomanip>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<ctime>
#include<deque>
#include<queue>
#include<stack>
#include<list>
using namespace std;
typedef long long ll; 
constexpr const int N=2e5;
constexpr const ll inf=0x3f3f3f3f3f3f3f3f;
int n,q,k,a[N+1],father[N+1],depth[N+1],dfn[N+1],rnk[N+1],son[N+1],size[N+1],top[N+1];
vector<int>g[N+1];
void dfs(int x,int fx){
	father[x]=fx;
	depth[x]=depth[fx]+1;
	size[x]=1;
	for(int v:g[x]){
		if(v==fx){
			continue;
		}
		dfs(v,x);
		if(size[v]>size[son[x]]){
			son[x]=v;
		}
		size[x]+=size[v];
	}
}
void dfs1(int x,int topx){
	top[x]=topx;
	static int cnt;
	dfn[x]=++cnt;
	rnk[cnt]=x;
	if(son[x]){
		dfs1(son[x],topx);
	}
	for(int v:g[x]){
		if(v==father[x]||v==son[x]){
			continue;
		}
		dfs1(v,v);
	}
}
struct ST{
	pair<int,int>st[N+1][__lg(N+1)+1];
	
	void build(int n){
		for(int i=1;i<=n;i++){
			st[i][0]={depth[rnk[i]],rnk[i]};
		}
		for(int i=1;(1<<i)<=n;i++){
			for(int x=1;x+(1<<i)-1<=n;x++){
				st[x][i]=min(st[x][i-1],st[x+(1<<i-1)][i-1]);
			}
		}
	}
	pair<int,int>query(int l,int r){
		int s=__lg(r-l+1);
		return min(st[l][s],st[r-(1<<s)+1][s]);
	}
}st;
int lca(int u,int v){
	if(u==v){
		return u;
	}
	if(dfn[u]>dfn[v]){
		swap(u,v);
	}
	return father[st.query(dfn[u]+1,dfn[v]).second];
}
void pre(int root=1){
	dfs(root,0);
	dfs1(root,root);
	st.build(n);
}
namespace k1{
	ll pre[N+1];
	void dfs(int x,int fx){
		pre[x]=pre[fx]+a[x];
		for(int v:g[x]){
			if(v==fx){
				continue;
			}
			dfs(v,x);
		}
	}
	int main(){
		dfs(1,0);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			cout<<pre[u]+pre[v]-pre[x]-pre[father[x]]<<'\n';
		}
		return 0;
	}
}
struct Matrix{
	int n,m;
	ll a[2][2];
	Matrix(int nn=-1,int mm=-1){
		if(mm==-1){
			mm=nn;
		}
		if(nn!=-1){
			n=nn,m=mm;
		}else{
			n=0,m=0;
		}
		unit();
	}
	Matrix(initializer_list<initializer_list<ll>> x){
		n=x.size();m=0;
		for(auto &i:x){
			m=max(m,(int)i.size());
		}
		int pi=0;
		for(auto &i:x){
			int pj=0;
			for(auto &j:i){
				a[pi][pj]=j;
				pj++;
			}
			pi++;
		}
	}
	ll* operator [](const int &x){
		return a[x];
	}
	void clear(){
		memset(a,0x3f,sizeof(a));
	}
	void unit(){
		clear();
		for(int i=0;i<n;i++){
			a[i][i]=0;
		}
	} 
	void print(){
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				cout<<a[i][j]<<' ';
			}
			cout<<endl;
		}
	}
};
Matrix operator *(Matrix A,Matrix B){
	Matrix C(A.n,B.m);
	for(int i=0;i<C.n;i++){
		for(int j=0;j<C.n;j++){
			C[i][j]=0;
		}
	} 
	for(int i=0;i<A.n;i++){
		for(int j=0;j<B.m;j++){
			C[i][j]=inf;
			for(int k=0;k<A.m;k++){
				C[i][j]=min(C[i][j],A[i][k]+B[k][j]);
			}
		}
	}
	return C;
}
Matrix& operator *=(Matrix &A,Matrix B){
	return A=A*B;
}
namespace k2{
	struct segTree{
		struct node{
			int l,r;
			Matrix up,down;
		}t[N<<2|1];
		
		void up(int p){
			t[p].up=t[p<<1|1].up*t[p<<1].up;
			t[p].down=t[p<<1].down*t[p<<1|1].down;
		}
		void build(int p,int l,int r){
			t[p]={l,r};
			if(l==r){
				t[p].up=t[p].down={
					{a[rnk[l]],a[rnk[l]]},
					{0,inf}
				};
				return;
			}
			int mid=l+r>>1;
			build(p<<1,l,mid);
			build(p<<1|1,mid+1,r);
			up(p);
		}
		Matrix queryUp(int p,int l,int r){
			if(l<=t[p].l&&t[p].r<=r){
				return t[p].up;
			}
			Matrix ans(2);
			if(t[p<<1|1].l<=r){
				ans=ans*queryUp(p<<1|1,l,r);
			}
			if(l<=t[p<<1].r){
				ans=ans*queryUp(p<<1,l,r);
			}
			return ans;
		}
		Matrix queryDown(int p,int l,int r){
			if(l<=t[p].l&&t[p].r<=r){
				return t[p].down;
			}
			Matrix ans(2);
			if(l<=t[p<<1].r){
				ans=ans*queryDown(p<<1,l,r);
			}
			if(t[p<<1|1].l<=r){
				ans=ans*queryDown(p<<1|1,l,r);
			}
			return ans;
		}
	}t;
	
	int main(){
		t.build(1,1,n);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			Matrix pl={{a[u],inf},{inf,inf}};
			while(top[u]!=top[x]){
				pl=t.queryDown(1,dfn[top[u]],dfn[u]-1)*pl;
				if(top[u]!=x){
					pl=Matrix({{a[father[top[u]]],a[father[top[u]]]},{0,inf}}) * pl;
				}
				u=father[top[u]];
			}
			if(u!=x){
				pl=t.queryDown(1,dfn[x],dfn[u]-1)*pl;
			}
			vector<pair<int,int>>p;
			while(top[v]!=top[x]){
				p.push_back({dfn[top[v]],dfn[v]});
				v=father[top[v]];
			}
			if(v!=x){
				p.push_back({dfn[x]+1,dfn[v]});
			}
			reverse(p.begin(),p.end());
			for(auto [l,r]:p){
				pl=t.queryUp(1,l,r)*pl;
			}
			cout<<pl[0][0]<<'\n';
//			vector<int>p,suf;
//			while(u!=x){
//				p.push_back(u);
//				u=father[u];
//			}
//			p.push_back(x);
//			while(v!=x){
//				suf.push_back(v);
//				v=father[v];
//			}
//			reverse(suf.begin(),suf.end());
//			for(int i:suf){
//				p.push_back(i);
//			}
//			static ll f[N+1];
//			f[0]=a[p[0]];
//			for(int i=1;i<p.size();i++){
//				f[i]=f[i-1];
//				for(int j=2;j<=k&&j<=i;j++){
//					f[i]=min(f[i],f[i-j]);
//				}
//				f[i]+=a[p[i]];
//			}
//			cout<<f[p.size()-1]<<'\n';
		}
		return 0;
	}
}
namespace k3{
	int main(){
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
		}
		return 0;
	}
}
int main(){
	/*freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);*/
	
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	
	cin>>n>>q>>k;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=1;i<n;i++){
		int u,v;
		cin>>u>>v;
		g[u].push_back(v);
		g[v].push_back(u);
	}
	pre();
	switch(k){
		case 1:
			k1::main();
			break;
		case 2:
			k2::main();
			break;
		case 3:
			k3::main();
			break;
	}
	
	cout.flush();
	
	/*fclose(stdin);
	fclose(stdout);*/
	return 0;
}

\(k=3\)

仍然考虑 DDP,先不考虑多组询问,把 \(u\sim v\) 的路径 \(p\) 拎出来做序列上的 DP,\(p\) 的下标从 \(0\) 开始。

对于路径上的点 \(p_i\),将其邻域节点中除去 \(p_{i-1},p_{i+1}\) 的 \(a\) 最小的节点记为 \(d(p_i)\)。

容易发现:

  • 从 \(p\) 上的点 \(x\) 出发,有效的操作只能跳到 \(p\) 往后的三个点 \(y,z,\alpha\),或者 \(d(x),d(y),d(z)\)。
  • 从 \(p\) 上的点 \(x\) 的子节点出发,有效的操作只能跳到 \(p\) 上往后的两个点 \(y,z\),或 \(d(y)\)。

由此可以设计序列 DP。

设 \(f_{i,0/1}\) 表示跳到 \(p_i\)、\(d(p_i)\) 的最小代价,答案即 \(f_{\vert p\vert-1,0}\)。

初始状态 \(f_{0,0}=a_{p_0},f_{0,1}=+\infty\)。

考虑转移,有:

\[\begin{aligned} f_{i,0}&=\min(f_{i-1,0},f_{i-1,1},f_{i-2,0},f_{i-2,1},f_{i-3,0})+a_{p_i}\\ f_{i,1}&=\min(f_{i,0},f_{i-1,0},f_{i-1,1},f_{i-2,0})+a_{d(p_i)}\\ \end{aligned} \]

于是做到了 \(\mathcal O\left(qn\right)\),实际得分 88pts。

序列 DP 参考代码
//#include<bits/stdc++.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<iomanip>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<ctime>
#include<deque>
#include<queue>
#include<stack>
#include<list>
using namespace std;
typedef long long ll; 
constexpr const int N=2e5;
constexpr const ll inf=0x3f3f3f3f3f3f3f3f;
int n,q,k,a[N+1],father[N+1],depth[N+1],dfn[N+1],rnk[N+1],son[N+1],size[N+1],top[N+1];
vector<int>g[N+1];
void dfs(int x,int fx){
	father[x]=fx;
	depth[x]=depth[fx]+1;
	size[x]=1;
	for(int v:g[x]){
		if(v==fx){
			continue;
		}
		dfs(v,x);
		if(size[v]>size[son[x]]){
			son[x]=v;
		}
		size[x]+=size[v];
	}
}
void dfs1(int x,int topx){
	top[x]=topx;
	static int cnt;
	dfn[x]=++cnt;
	rnk[cnt]=x;
	if(son[x]){
		dfs1(son[x],topx);
	}
	for(int v:g[x]){
		if(v==father[x]||v==son[x]){
			continue;
		}
		dfs1(v,v);
	}
}
struct ST{
	pair<int,int>st[N+1][__lg(N+1)+1];
	
	void build(int n){
		for(int i=1;i<=n;i++){
			st[i][0]={depth[rnk[i]],rnk[i]};
		}
		for(int i=1;(1<<i)<=n;i++){
			for(int x=1;x+(1<<i)-1<=n;x++){
				st[x][i]=min(st[x][i-1],st[x+(1<<i-1)][i-1]);
			}
		}
	}
	pair<int,int>query(int l,int r){
		int s=__lg(r-l+1);
		return min(st[l][s],st[r-(1<<s)+1][s]);
	}
}st;
int lca(int u,int v){
	if(u==v){
		return u;
	}
	if(dfn[u]>dfn[v]){
		swap(u,v);
	}
	return father[st.query(dfn[u]+1,dfn[v]).second];
}
void pre(int root=1){
	dfs(root,0);
	dfs1(root,root);
	st.build(n);
}
namespace k1{
	ll pre[N+1];
	void dfs(int x,int fx){
		pre[x]=pre[fx]+a[x];
		for(int v:g[x]){
			if(v==fx){
				continue;
			}
			dfs(v,x);
		}
	}
	int main(){
		dfs(1,0);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			cout<<pre[u]+pre[v]-pre[x]-pre[father[x]]<<'\n';
		}
		return 0;
	}
}
struct Matrix{
	int n,m;
	ll a[2][2];
	Matrix(int nn=-1,int mm=-1){
		if(mm==-1){
			mm=nn;
		}
		if(nn!=-1){
			n=nn,m=mm;
		}else{
			n=0,m=0;
		}
		unit();
	}
	Matrix(initializer_list<initializer_list<ll>> x){
		n=x.size();m=0;
		for(auto &i:x){
			m=max(m,(int)i.size());
		}
		int pi=0;
		for(auto &i:x){
			int pj=0;
			for(auto &j:i){
				a[pi][pj]=j;
				pj++;
			}
			pi++;
		}
	}
	ll* operator [](const int &x){
		return a[x];
	}
	void clear(){
		memset(a,0x3f,sizeof(a));
	}
	void unit(){
		clear();
		for(int i=0;i<n;i++){
			a[i][i]=0;
		}
	} 
	void print(){
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				cout<<a[i][j]<<' ';
			}
			cout<<endl;
		}
	}
};
Matrix operator *(Matrix A,Matrix B){
	Matrix C(A.n,B.m);
	for(int i=0;i<C.n;i++){
		for(int j=0;j<C.n;j++){
			C[i][j]=0;
		}
	} 
	for(int i=0;i<A.n;i++){
		for(int j=0;j<B.m;j++){
			C[i][j]=inf;
			for(int k=0;k<A.m;k++){
				C[i][j]=min(C[i][j],A[i][k]+B[k][j]);
			}
		}
	}
	return C;
}
Matrix& operator *=(Matrix &A,Matrix B){
	return A=A*B;
}
namespace k2{
	struct segTree{
		struct node{
			int l,r;
			Matrix up,down;
		}t[N<<2|1];
		
		void up(int p){
			t[p].up=t[p<<1|1].up*t[p<<1].up;
			t[p].down=t[p<<1].down*t[p<<1|1].down;
		}
		void build(int p,int l,int r){
			t[p]={l,r};
			if(l==r){
				t[p].up=t[p].down={
					{a[rnk[l]],a[rnk[l]]},
					{0,inf}
				};
				return;
			}
			int mid=l+r>>1;
			build(p<<1,l,mid);
			build(p<<1|1,mid+1,r);
			up(p);
		}
		Matrix queryUp(int p,int l,int r){
			if(l<=t[p].l&&t[p].r<=r){
				return t[p].up;
			}
			Matrix ans(2);
			if(t[p<<1|1].l<=r){
				ans=ans*queryUp(p<<1|1,l,r);
			}
			if(l<=t[p<<1].r){
				ans=ans*queryUp(p<<1,l,r);
			}
			return ans;
		}
		Matrix queryDown(int p,int l,int r){
			if(l<=t[p].l&&t[p].r<=r){
				return t[p].down;
			}
			Matrix ans(2);
			if(l<=t[p<<1].r){
				ans=ans*queryDown(p<<1,l,r);
			}
			if(t[p<<1|1].l<=r){
				ans=ans*queryDown(p<<1|1,l,r);
			}
			return ans;
		}
	}t;
	
	int main(){
		t.build(1,1,n);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			Matrix pl={{a[u],inf},{inf,inf}};
			while(top[u]!=top[x]){
				pl=t.queryDown(1,dfn[top[u]],dfn[u]-1)*pl;
				if(top[u]!=x){
					pl=Matrix({{a[father[top[u]]],a[father[top[u]]]},{0,inf}}) * pl;
				}
				u=father[top[u]];
			}
			if(u!=x){
				pl=t.queryDown(1,dfn[x],dfn[u]-1)*pl;
			}
			vector<pair<int,int>>p;
			while(top[v]!=top[x]){
				p.push_back({dfn[top[v]],dfn[v]});
				v=father[top[v]];
			}
			if(v!=x){
				p.push_back({dfn[x]+1,dfn[v]});
			}
			reverse(p.begin(),p.end());
			for(auto [l,r]:p){
				pl=t.queryUp(1,l,r)*pl;
			}
			cout<<pl[0][0]<<'\n';
		}
		return 0;
	}
}
namespace k3{
	int d(int x,vector<int>v){
		if(g[x].size()<=v.size()){
			return 0;
		}
		for(int i:g[x]){
			bool flag=true;
			for(int j:v){
				if(i==j){
					flag=false;
					break;
				}
			}
			if(flag){
				return i;
			}
		}
	}
	int main(){
		for(int x=1;x<=n;x++){
			sort(g[x].begin(),g[x].end(),[](int i,int j){
				return a[i]<a[j];
			});
		}
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			vector<int>p,suf;
			while(u!=x){
				p.push_back(u);
				u=father[u];
			}
			p.push_back(x);
			while(v!=x){
				suf.push_back(v);
				v=father[v];
			}
			reverse(suf.begin(),suf.end());
			for(int i:suf){
				p.push_back(i);
			}
			static ll f[N+1][2];
			f[0][0]=a[p[0]];
			f[0][1]=inf;
			a[0]=inf;
			for(int i=1;i<p.size();i++){
				f[i][0]=min({f[i-1][0],f[i-1][1]});
				if(2<=i){
					f[i][0]=min({f[i][0],f[i-2][0],f[i-2][1]});
				}
				if(3<=i){
					f[i][0]=min(f[i][0],f[i-3][0]);
				}
				f[i][0]+=a[p[i]];
				if(i+1<p.size()){
					f[i][1]=min({f[i][0],f[i-1][0],f[i-1][1]});
					if(2<=i){
						f[i][1]=min(f[i][1],f[i-2][0]);
					}
					f[i][1]+=a[d(p[i],{p[i-1],p[i+1]})];
				}else{
					f[i][1]=inf;
				}
			}
			cout<<f[p.size()-1][0]<<'\n';
		}
		return 0;
	}
}
int main(){
	/*freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);*/
	
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	
	cin>>n>>q>>k;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=1;i<n;i++){
		int u,v;
		cin>>u>>v;
		g[u].push_back(v);
		g[v].push_back(u);
	}
	pre();
	switch(k){
		case 1:
			k1::main();
			break;
		case 2:
			k2::main();
			break;
		case 3:
			k3::main();
			break;
	}
	
	cout.flush();
	
	/*fclose(stdin);
	fclose(stdout);*/
	return 0;
}

考虑放到树剖线段树上优化这个 DP:

\[\begin{aligned} f_{i,0}&=\min(f_{i-1,0},f_{i-1,1},f_{i-2,0},f_{i-2,1},f_{i-3,0})+a_{p_i}\\ f_{i,1}&=\min(f_{i,0},f_{i-1,0},f_{i-1,1},f_{i-2,0})+a_{d(p_i)}\\ \end{aligned} \]

对于原来的递推式,\(f_{i,1}\) 需要用到 \(f_{i,0}\),不太好维护,展开:

\[\begin{aligned} f_{i,0}&=\min(f_{i-1,0},f_{i-1,1},f_{i-2,0},f_{i-2,1},f_{i-3,0})+a_{p_i}\\ f_{i,1}&=\min(f_{i-1,0},f_{i-1,1},f_{i-2,0},f_{i-2,1}+a_{p_i},f_{i-3,0}+a_{p_i})+a_{d(p_i)}\\ \end{aligned} \]

打包成 \(5\times5\) 的矩阵转移,设 \(f_x\) 表示从底下的某个起点往上跳到 \(x\) 的最小代价,\(y\) 为 \(x\) 的重子节点,\(z\) 为 \(y\) 的重子节点,\(\alpha\) 为 \(z\) 的重子节点,有:

\[\begin{bmatrix} a_x&a_x&a_x&a_x&a_x\\ a_{d(x)}&a_{d(x)}&a_{d(x)}&a_x+a_{d(x)}&a_x+a_{d(x)}\\ 0\\ &0\\ &&0 \end{bmatrix} \begin{bmatrix} f_{y,0}\\ f_{y,1}\\ f_{z,0}\\ f_{z,1}\\ f_{\alpha,0} \end{bmatrix} = \begin{bmatrix} f_{x,0}\\ f_{x,1}\\ f_{y,0}\\ f_{y,1}\\ f_{z,0}\\ \end{bmatrix} \]

从上往下跳是类似的。

于是容易线段树维护,需要特判 \(\operatorname{lca}(u,v)\)。需要找到 \(x=\operatorname{lca}(u,v)\) 的 \(u,v\) 方向的子节点 \(u_0,v_0\),然后在 \(x\) 的邻域节点里去除 \(u_0,v_0\)。

朴素 DDP 参考代码
//#include<bits/stdc++.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<iomanip>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<ctime>
#include<deque>
#include<queue>
#include<stack>
#include<list>
using namespace std;
typedef long long ll;
constexpr const int N=2e5;
constexpr const ll inf=0x3f3f3f3f3f3f3f3f;
int n,q,k,father[N+1],depth[N+1],dfn[N+1],rnk[N+1],son[N+1],size[N+1],top[N+1];
ll a[N+1];
vector<int>g[N+1];
void dfs(int x,int fx){
	father[x]=fx;
	depth[x]=depth[fx]+1;
	size[x]=1;
	for(int v:g[x]){
		if(v==fx){
			continue;
		}
		dfs(v,x);
		if(size[v]>size[son[x]]){
			son[x]=v;
		}
		size[x]+=size[v];
	}
}
void dfs1(int x,int topx){
	top[x]=topx;
	static int cnt;
	dfn[x]=++cnt;
	rnk[cnt]=x;
	if(son[x]){
		dfs1(son[x],topx);
	}
	for(int v:g[x]){
		if(v==father[x]||v==son[x]){
			continue;
		}
		dfs1(v,v);
	}
}
struct ST{
	pair<int,int>st[N+1][__lg(N+1)+1];
	
	void build(int n){
		for(int i=1;i<=n;i++){
			st[i][0]={depth[rnk[i]],rnk[i]};
		}
		for(int i=1;(1<<i)<=n;i++){
			for(int x=1;x+(1<<i)-1<=n;x++){
				st[x][i]=min(st[x][i-1],st[x+(1<<i-1)][i-1]);
			}
		}
	}
	pair<int,int>query(int l,int r){
		int s=__lg(r-l+1);
		return min(st[l][s],st[r-(1<<s)+1][s]);
	}
}st;
int lca(int u,int v){
	if(u==v){
		return u;
	}
	if(dfn[u]>dfn[v]){
		swap(u,v);
	}
	return father[st.query(dfn[u]+1,dfn[v]).second];
}
void pre(int root=1){
	dfs(root,0);
	dfs1(root,root);
	st.build(n);
}
namespace k1{
	ll pre[N+1];
	void dfs(int x,int fx){
		pre[x]=pre[fx]+a[x];
		for(int v:g[x]){
			if(v==fx){
				continue;
			}
			dfs(v,x);
		}
	}
	int main(){
		dfs(1,0);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			cout<<pre[u]+pre[v]-pre[x]-pre[father[x]]<<'\n';
		}
		return 0;
	}
}
template<int N,int M>
struct Matrix{
	int n,m;
	ll a[N][M];
	Matrix(int nn=-1,int mm=-1){
		if(mm==-1){
			mm=nn;
		}
		if(nn!=-1){
			n=nn,m=mm;
		}else{
			n=0,m=0;
		}
		unit();
	}
	Matrix(initializer_list<initializer_list<ll>> x){
		n=x.size();m=0;
		for(auto &i:x){
			m=max(m,(int)i.size());
		}
		clear();
		int pi=0;
		for(auto &i:x){
			int pj=0;
			for(auto &j:i){
				a[pi][pj]=j;
				pj++;
			}
			pi++;
		}
	}
	ll* operator [](const int &x){
		return a[x];
	}
	void clear(){
		memset(a,0x3f,sizeof(a));
	}
	void unit(){
		clear();
		if(n==m){
			for(int i=0;i<n;i++){
				a[i][i]=0;
			}
		}
	} 
	void print(){
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				cout<<a[i][j]<<' ';
			}
			cout<<endl;
		}
	}
};
template<int N,int M,int R>
Matrix<N,R> operator *(Matrix<N,M> A,Matrix<M,R> B){
	Matrix<N,R> C(A.n,B.m);
	C.clear();
	for(int i=0;i<A.n;i++){
		for(int j=0;j<B.m;j++){
			C[i][j]=inf;
			for(int k=0;k<A.m;k++){
				C[i][j]=min(C[i][j],A[i][k]+B[k][j]);
			}
		}
	}
	return C;
}
template<int N,int M,int R>
Matrix<N,R>& operator *=(Matrix<N,M> &A,Matrix<M,R> B){
	return A=A*B;
}
template<int N,int M,class base>
struct segTree{
	#define Matrix Matrix<N,M>
	struct node{
		int l,r;
		Matrix up,down;
	}t[::N<<2|1];
	
	void up(int p){
		t[p].up=t[p<<1|1].up*t[p<<1].up;
		t[p].down=t[p<<1].down*t[p<<1|1].down;
	}
	void build(int p,int l,int r){
		t[p]={l,r};
		if(l==r){
			base calc;
			t[p].up=t[p].down=calc(l);
			return;
		}
		int mid=l+r>>1;
		build(p<<1,l,mid);
		build(p<<1|1,mid+1,r);
		up(p);
	}
	Matrix queryUp(int p,int l,int r){
		if(l<=t[p].l&&t[p].r<=r){
			return t[p].up;
		}
		Matrix ans(N,M);
		if(t[p<<1|1].l<=r){
			ans=ans*queryUp(p<<1|1,l,r);
		}
		if(l<=t[p<<1].r){
			ans=ans*queryUp(p<<1,l,r);
		}
		return ans;
	}
	Matrix queryDown(int p,int l,int r){
		if(l<=t[p].l&&t[p].r<=r){
			return t[p].down;
		}
		Matrix ans(N,M);
		if(l<=t[p<<1].r){
			ans=ans*queryDown(p<<1,l,r);
		}
		if(t[p<<1|1].l<=r){
			ans=ans*queryDown(p<<1|1,l,r);
		}
		return ans;
	}
	#undef Matrix
};
namespace k2{
	struct base{
		Matrix<2,2> operator ()(int x){
			return {
				{a[rnk[x]],a[rnk[x]]},
				{0,inf}
			};
		}
	};
	segTree<2,2,base> t;
	int main(){
		t.build(1,1,n);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			Matrix<2,1> pl={
				{a[u]},
				{inf}
			};
			while(top[u]!=top[x]){
				pl=t.queryDown(1,dfn[top[u]],dfn[u]-1)*pl;
				if(top[u]!=x){
					u=father[top[u]];
					pl=Matrix<2,2>{
						{a[u],a[u]},
						{0,inf}
					}*pl;
				}else{
					u=father[top[u]];
				}
			}
			if(u!=x){
				pl=t.queryDown(1,dfn[x],dfn[u]-1)*pl;
			}
			vector<pair<int,int>>p;
			while(top[v]!=top[x]){
				p.push_back({dfn[top[v]],dfn[v]});
				v=father[top[v]];
			}
			if(v!=x){
				p.push_back({dfn[x]+1,dfn[v]});
			}
			reverse(p.begin(),p.end());
			for(auto [l,r]:p){
				pl=t.queryUp(1,l,r)*pl;
			}
			cout<<pl[0][0]<<'\n';
		}
		return 0;
	}
}
namespace k3{
	int d(int x,vector<int>v){
		sort(v.begin(),v.end(),greater<int>());
		while(v.size()&&v.back()==0){
			v.pop_back();
		} 
		if(g[x].size()<=v.size()){
			return 0;
		}
		for(int i:g[x]){
			bool flag=true;
			for(int j:v){
				if(i==j){
					flag=false;
					break;
				}
			}
			if(flag){
				return i;
			}
		}
		return 0;
	}
	struct base{
		Matrix<5,5> operator ()(int x){
			x=rnk[x];
			int ad=a[d(x,{father[x],son[x]})];
			return {
				{a[x],a[x],a[x],a[x],a[x]},
				{ad,ad,ad,a[x]+ad,a[x]+ad},
				{0},
				{inf,0},
				{inf,inf,0},
			};
		}
	};
	int getSon(int x,int u){
		while(top[u]!=top[x]){
			if(father[top[u]]==x){
				return top[u];
			}
			u=father[top[u]];
		}
		return son[x];
	}
	segTree<5,5,base> t;
	int main(){
		for(int x=1;x<=n;x++){
			sort(g[x].begin(),g[x].end(),[](int i,int j){
				return a[i]<a[j];
			});
		}
		a[0]=inf;
		t.build(1,1,n);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			int nx=0;
			if(v!=x){
				nx=getSon(x,v);
			} 
			Matrix<5,1> pl={
				{a[u]},
				{inf},
				{inf},
				{inf},
				{inf}
			};
			while(top[u]!=top[x]){
				if(dfn[top[u]]<=dfn[u]-1){
					pl=t.queryDown(1,dfn[top[u]],dfn[u]-1)*pl;
				}
				int y=top[u];
				u=father[top[u]];
				ll ad;
				if(u==x){
					ad=a[d(u,{y,nx})];
				}else{
					ad=a[d(u,{y,father[u]})];
				}
				pl=Matrix<5,5>{
					{a[u],a[u],a[u],a[u],a[u]},
					{ad,ad,ad,a[u]+ad,a[u]+ad},
					{0},
					{inf,0},
					{inf,inf,0},
				}*pl;
			}
			if(u!=x){
				if(dfn[x]+1<=dfn[u]-1){
					pl=t.queryDown(1,dfn[x]+1,dfn[u]-1)*pl;
				}
				ll ad=a[d(x,{son[x],nx})];
				pl=Matrix<5,5>{
					{a[x],a[x],a[x],a[x],a[x]},
					{ad,ad,ad,a[x]+ad,a[x]+ad},
					{0},
					{inf,0},
					{inf,inf,0},
				}*pl;
			}
			vector<pair<int,int>>p;
			while(top[v]!=top[x]){
				p.push_back({dfn[top[v]],dfn[v]});
				v=father[top[v]];
			}
			if(v!=x){
				p.push_back({dfn[x]+1,dfn[v]});
			}
			reverse(p.begin(),p.end());
			for(auto i=0;i+1<p.size();i++){
				auto [l,r]=p[i];
				if(l<=r-1){
					pl=t.queryUp(1,l,r-1)*pl;
				}
				ll ad=a[d(rnk[r],{father[rnk[r]],rnk[p[i+1].first]})];
				pl=Matrix<5,5>{
					{a[rnk[r]],a[rnk[r]],a[rnk[r]],a[rnk[r]],a[rnk[r]]},
					{ad,ad,ad,a[rnk[r]]+ad,a[rnk[r]]+ad},
					{0},
					{inf,0},
					{inf,inf,0},
				}*pl;
			}
			if(p.size()){
				auto [l,r]=p.back();
				pl=t.queryUp(1,l,r)*pl;
			}
			cout<<pl[0][0]<<'\n';
		}
		return 0;
	}
}
int main(){
	/*freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);*/
	
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	
	cin>>n>>q>>k;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=1;i<n;i++){
		int u,v;
		cin>>u>>v;
		g[u].push_back(v);
		g[v].push_back(u);
	}
	pre();
	switch(k){
		case 1:
			k1::main();
			break;
		case 2:
			k2::main();
			break;
		case 3:
			k3::main();
			break;
	}
	
	cout.flush();
	
	/*fclose(stdin);
	fclose(stdout);*/
	return 0;
}
/*
6 1 3
1 100 100 10 100 10
1 2
2 3
3 4
2 5
5 6
4 6

21 
*/ 

时间复杂度 \(\mathcal O\left(5^3q\log^2n\right)\)然而由于常数过大,实际得分 88pts,和上一份代码一样。

卡常小技巧

直接做的时间复杂度为 \(\mathcal O\left(5^3q\log^2n\right)\),期望得分 88pts。

考虑把统计答案的 \(\textit{ans}\) 列向量传实参放入线段树查询操作中递归,每次直接 \(\mathcal O(5^2)\) 乘上答案,于是时间复杂度降为了 \(\mathcal O\left(5^2q\log^2n\right)\)。

AC 代码

//#include<bits/stdc++.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<iomanip>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<ctime>
#include<deque>
#include<queue>
#include<stack>
#include<list>
using namespace std;
typedef long long ll;
constexpr const int N=2e5;
constexpr const ll inf=0x3f3f3f3f3f3f3f3f;
int n,q,k,father[N+1],depth[N+1],dfn[N+1],rnk[N+1],son[N+1],size[N+1],top[N+1];
ll a[N+1];
vector<int>g[N+1];
void dfs(int x,int fx){
	static int s[N+1];
	int cnt=1;
	s[cnt]=x;
	father[x]=fx;
	depth[x]=depth[fx]+1;
	for(int i=1;i<=cnt;i++){
		int y=s[i];
		for(int v:g[y]){
			if(v==father[y]){
				continue;
			}
			father[v]=y;
			depth[v]=depth[y]+1;
			s[++cnt]=v;
		}
	}
	for(int i=cnt;i>=1;i--){
		int y=s[i];
		::size[y]=1;
		for(int v:g[y]){
			if(v==father[y]){
				continue;
			}
			if(::size[v]>::size[son[y]]){
				son[y]=v;
			}
			::size[y]+=::size[v];
		}
	}
}
void dfs1(int x,int topx){
	static int s[N+1],tp[N+1];
	static int cnt;
	int rear=1;
	s[rear]=x;
	tp[rear]=topx;
	while(rear){
		int y=s[rear],ty=tp[rear];
		rear--;
		top[y]=ty;
		dfn[y]=++cnt;
		rnk[cnt]=y;
		for(int i=(int)g[y].size()-1;i>=0;i--){
			int v=g[y][i];
			if(v==father[y]||v==son[y]){
				continue;
			}
			s[++rear]=v;
			tp[rear]=v;
		}
		if(son[y]){
			s[++rear]=son[y];
			tp[rear]=ty;
		}
	}
}
struct ST{
	pair<int,int>st[N+1][__lg(N+1)+1];
	
	void build(int n){
		for(int i=1;i<=n;i++){
			st[i][0]={depth[rnk[i]],rnk[i]};
		}
		for(int i=1;(1<<i)<=n;i++){
			for(int x=1;x+(1<<i)-1<=n;x++){
				st[x][i]=min(st[x][i-1],st[x+(1<<i-1)][i-1]);
			}
		}
	}
	pair<int,int>query(int l,int r){
		int s=__lg(r-l+1);
		return min(st[l][s],st[r-(1<<s)+1][s]);
	}
}st;
int lca(int u,int v){
	if(u==v){
		return u;
	}
	if(dfn[u]>dfn[v]){
		swap(u,v);
	}
	return father[st.query(dfn[u]+1,dfn[v]).second];
}
void pre(int root=1){
	dfs(root,0);
	dfs1(root,root);
	st.build(n);
}
namespace k1{
	ll pre[N+1];
	void dfs(int x,int fx){
		static int s[N+1];
		int cnt=1;
		s[cnt]=x;
		pre[x]=pre[fx]+a[x];
		for(int i=1;i<=cnt;i++){
			int y=s[i];
			for(int v:g[y]){
				if(v==father[y]){
					continue;
				}
				pre[v]=pre[y]+a[v];
				s[++cnt]=v;
			}
		}
	}
	int main(){
		dfs(1,0);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			cout<<pre[u]+pre[v]-pre[x]-pre[father[x]]<<'\n';
		}
		return 0;
	}
}
template<int N,int M>
struct Matrix{
	int n,m;
	ll a[N][M];
	Matrix(int nn=-1,int mm=-1){
		if(mm==-1){
			mm=nn;
		}
		if(nn!=-1){
			n=nn,m=mm;
		}else{
			n=0,m=0;
		}
		unit();
	}
	Matrix(initializer_list<initializer_list<ll>> x){
		n=x.size();m=0;
		for(auto &i:x){
			m=max(m,(int)i.size());
		}
		clear();
		int pi=0;
		for(auto &i:x){
			int pj=0;
			for(auto &j:i){
				a[pi][pj]=j;
				pj++;
			}
			pi++;
		}
	}
	ll* operator [](const int &x){
		return a[x];
	}
	void clear(){
		memset(a,0x3f,sizeof(a));
	}
	void unit(){
		clear();
		if(n==m){
			for(int i=0;i<n;i++){
				a[i][i]=0;
			}
		}
	} 
	void print(){
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				cout<<a[i][j]<<' ';
			}
			cout<<endl;
		}
	}
};
template<int N,int M,int R>
Matrix<N,R> operator *(Matrix<N,M> A,Matrix<M,R> B){
	Matrix<N,R> C;
	C.n=A.n,C.m=B.m;
	for(int i=0;i<N;i++){
		for(int k=0;k<M;k++){
			ll v=A[i][k];
			for(int j=0;j<R;j++){
				C[i][j]=min(C[i][j],v+B[k][j]);
			}
		}
	}
	return C;
}
template<int N,int M,int R>
Matrix<N,R>& operator *=(Matrix<N,M> &A,Matrix<M,R> B){
	return A=A*B;
}
template<int N,int M,class base>
struct segTree{
	#define Matrix Matrix<N,M>
	struct node{
		int l,r;
		Matrix up,down;
	}t[::N<<2|1];
	
	void up(int p){
		t[p].up=t[p<<1|1].up*t[p<<1].up;
		t[p].down=t[p<<1].down*t[p<<1|1].down;
	}
	void build(int p,int l,int r){
		t[p]={l,r};
		if(l==r){
			base calc;
			t[p].up=t[p].down=calc(l);
			return;
		}
		int mid=l+r>>1;
		build(p<<1,l,mid);
		build(p<<1|1,mid+1,r);
		up(p);
	}
	Matrix queryUp(int p,int l,int r){
		if(l<=t[p].l&&t[p].r<=r){
			return t[p].up;
		}
		Matrix ans(N,M);
		if(t[p<<1|1].l<=r){
			ans=ans*queryUp(p<<1|1,l,r);
		}
		if(l<=t[p<<1].r){
			ans=ans*queryUp(p<<1,l,r);
		}
		return ans;
	}
	Matrix queryDown(int p,int l,int r){
		if(l<=t[p].l&&t[p].r<=r){
			return t[p].down;
		}
		Matrix ans(N,M);
		if(l<=t[p<<1].r){
			ans=ans*queryDown(p<<1,l,r);
		}
		if(t[p<<1|1].l<=r){
			ans=ans*queryDown(p<<1|1,l,r);
		}
		return ans;
	}
	#undef Matrix
	void applyUp(int p,int l,int r,Matrix<N,1> &pl){
		if(l<=t[p].l&&t[p].r<=r){
			pl=t[p].up*pl;
			return;
		}
		if(l<=t[p<<1].r){
			applyUp(p<<1,l,r,pl);
		}
		if(t[p<<1|1].l<=r){
			applyUp(p<<1|1,l,r,pl);
		}
	}
	void applyDown(int p,int l,int r,Matrix<N,1> &pl){
		if(l<=t[p].l&&t[p].r<=r){
			pl=t[p].down*pl;
			return;
		}
		if(t[p<<1|1].l<=r){
			applyDown(p<<1|1,l,r,pl);
		}
		if(l<=t[p<<1].r){
			applyDown(p<<1,l,r,pl);
		}
	}
};
namespace k2{
	struct base{
		Matrix<2,2> operator ()(int x){
			return {
				{a[rnk[x]],a[rnk[x]]},
				{0,inf}
			};
		}
	};
	segTree<2,2,base> t;
	int main(){
		t.build(1,1,n);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			Matrix<2,1> pl={
				{a[u]},
				{inf}
			};
			while(top[u]!=top[x]){
				t.applyDown(1,dfn[top[u]],dfn[u]-1,pl);
				if(top[u]!=x){
					u=father[top[u]];
					pl=Matrix<2,2>{
						{a[u],a[u]},
						{0,inf}
					}*pl;
				}else{
					u=father[top[u]];
				}
			}
			if(u!=x){
				t.applyDown(1,dfn[x],dfn[u]-1,pl);
			}
			vector<pair<int,int>>p;
			while(top[v]!=top[x]){
				p.push_back({dfn[top[v]],dfn[v]});
				v=father[top[v]];
			}
			if(v!=x){
				p.push_back({dfn[x]+1,dfn[v]});
			}
			reverse(p.begin(),p.end());
			for(auto [l,r]:p){
				t.applyUp(1,l,r,pl);
			}
			cout<<pl[0][0]<<'\n';
		}
		return 0;
	}
}
namespace k3{
	int d(int x,int u,int v){
		for(int i:g[x]){
			if(i!=u&&i!=v){
				return i;
			}
		}
		return 0;
	}
	int getSon(int x,int u){
		while(top[u]!=top[x]){
			if(father[top[u]]==x){
				return top[u];
			}
			u=father[top[u]];
		}
		return son[x];
	}
	Matrix<5,5> calc(int x,int u,int v){
		ll ad=a[d(x,u,v)];
		return {
			{a[x],a[x],a[x],a[x],a[x]},
			{ad,ad,ad,a[x]+ad,a[x]+ad},
			{0},
			{inf,0},
			{inf,inf,0},
		};
	}
	struct base{
		Matrix<5,5> operator ()(int x){
			x=rnk[x];
			return calc(x,father[x],son[x]);
		}
	};
	segTree<5,5,base> t;
	int main(){
		for(int x=1;x<=n;x++){
			sort(g[x].begin(),g[x].end(),[](int i,int j){
				return a[i]<a[j];
			});
		}
		a[0]=inf;
		t.build(1,1,n);
		while(q--){
			int u,v;
			cin>>u>>v;
			int x=lca(u,v);
			int nx=0;
			if(v!=x){
				nx=getSon(x,v);
			}
			Matrix<5,1> pl={
				{a[u]},
				{inf},
				{inf},
				{inf},
				{inf}
			};
			while(top[u]!=top[x]){
				int y=top[u];
				if(dfn[y]<=dfn[u]-1){
					t.applyDown(1,dfn[y],dfn[u]-1,pl);
				}
				u=father[y];
				if(u==x){
					pl=calc(u,y,nx)*pl;
				}else{
					pl=calc(u,father[u],y)*pl;
				}
			}
			if(u!=x){
				if(dfn[x]+1<=dfn[u]-1){
					t.applyDown(1,dfn[x]+1,dfn[u]-1,pl);
				}
				pl=calc(x,son[x],nx)*pl;
			}
			static pair<int,int>p[64];
			int cnt=0;
			while(top[v]!=top[x]){
				p[++cnt]={dfn[top[v]],dfn[v]};
				v=father[top[v]];
			}
			if(v!=x){
				p[++cnt]={dfn[x]+1,dfn[v]};
			}
			for(int i=cnt;i>=1;i--){
				int l=p[i].first,r=p[i].second;
				if(i>1){
					if(l<=r-1){
						t.applyUp(1,l,r-1,pl);
					}
					int y=rnk[r],z=rnk[p[i-1].first];
					pl=calc(y,father[y],z)*pl;
				}else{
					t.applyUp(1,l,r,pl);
				}
			}
			cout<<pl[0][0]<<'\n';
		}
		return 0;
	}
}
int main(){
	/*freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);*/
	
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	
	cin>>n>>q>>k;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=1;i<n;i++){
		int u,v;
		cin>>u>>v;
		g[u].push_back(v);
		g[v].push_back(u);
	}
	pre();
	switch(k){
		case 1:
			k1::main();
			break;
		case 2:
			k2::main();
			break;
		case 3:
			k3::main();
			break;
	}
	
	cout.flush();
	
	/*fclose(stdin);
	fclose(stdout);*/
	return 0;
}
/*
6 1 3
1 100 100 10 100 10
1 2
2 3
3 4
2 5
5 6
4 6

21 
*/
posted @ 2026-10-22 19:46  TH911  阅读(10)  评论(0)    收藏  举报