题解:[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\) 的重子节点,有:
\((\min,+)\) 矩阵维护。
再考虑从上往下跳到 \(z\),设 \(x\) 为 \(y\) 的父节点,\(y\) 为 \(z\) 的父节点,有:
于是容易线段树维护。需要特判 \(\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\)。
考虑转移,有:
于是做到了 \(\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:
对于原来的递推式,\(f_{i,1}\) 需要用到 \(f_{i,0}\),不太好维护,展开:
打包成 \(5\times5\) 的矩阵转移,设 \(f_x\) 表示从底下的某个起点往上跳到 \(x\) 的最小代价,\(y\) 为 \(x\) 的重子节点,\(z\) 为 \(y\) 的重子节点,\(\alpha\) 为 \(z\) 的重子节点,有:
从上往下跳是类似的。
于是容易线段树维护,需要特判 \(\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
*/

浙公网安备 33010602011771号