[TK] 寻宝游戏

在树上标记若干个点，求出从某个点走过全部点并回到该点的最小路径. 有多次询问，每次询问只改变一个点.

首先是一个暴力的思路.

会发现，从标记点中的其中一个开始走，结果一定更优，并且无论从哪个点开始走，其结果都是相同的. 假若不考虑还要走回来，那么答案就应该是标记点两两之间路径和的最小值，至于还要走回来，可以发现走回来的最优策略相同，因此答案乘二即可.

因此这个题就转化为求标记点两两之间路径和的最小值. 考虑到：将这些点按 DFS 序排序，得到的结果会是最小的. 为了使答案最小，可以想到将相邻的点都放到一起，或者说在这里是将距离最近的点放到一起，因此我么用节点在 DFS 序上的距离来刻画实际距离，因此按 DFS 序排序.

随后，可以想到对每一对相邻的点跑一遍 LCA，求出简单路径长. 可以发现，假如我们将 \(dist(1,n)\) 也加入答案的话，正好在每个点都出入了一遍，因此求出来的正好是走一个来回的贡献.

贴上暴力代码

#include<bits/stdc++.h>
using namespace std;
#define int long long
namespace reader{
	template<typename T>
	inline void read(T& x){
		x=0;bool sym=0;char c=getchar();
	    while(!isdigit(c)){sym^=(c=='-');c=getchar();}
	    while(isdigit(c)){x=x*10+c-48;c=getchar();}
	    if(sym)x=-x;
	}
	template<size_t N>
	inline void read(char (&str)[N]){
	    size_t n=0;char c=getchar();
	    while(n<N-1&&!isspace(c)){str[n]=c;c=getchar();++n;}
	    str[n]=0;
	}
	template<typename T,size_t N>
	inline void read(T (&a)[N],int range=N){
		for(int i=1;i<=range;++i){read(a[i]);}
	}
	template<typename T,typename... Args>
	inline void read(T& x,Args&... args){
	    read(x);read(args...);
	}
	template<typename T,typename T2>
	inline void readarray(T& x,T2& args){
		read(x);read(args,x);
	}
	template<typename func,typename... Args>
	inline void readact(int x,function<func>fu,Args&... args){
		for(int i=1;i<=x;++i){
			read(args...);
			fu(args...);
		}
	}
}
using namespace reader;
int n,m;
int fa[100001][17];
int w[100001][17];
struct edge{
	int to,w;
};
int deep[100001],dfn[100001],dfncnt;
vector<edge>e[100001];
void dfs(int now,int last,int lastw,int nowdeep){
	dfn[now]=++dfncnt;
	deep[now]=nowdeep;
	fa[now][0]=last;
	w[now][0]=lastw;
	for(int i=1;i<=16;++i){
		fa[now][i]=fa[fa[now][i-1]][i-1];
		w[now][i]=w[fa[now][i-1]][i-1]+w[now][i-1];
	}
	for(edge i:e[now]){
		if(i.to!=last){
			dfs(i.to,now,i.w,nowdeep+1);
		}
	}
}
int lca(int x,int y){
//	cout<<"lca "<<x<<" "<<y<<endl;
	if(deep[x]<deep[y]) swap(x,y);
	int res=0;
	for(int i=16;i>=0;--i){
		if(deep[x]-deep[y]>=(1<<i)){
//			cout<<"jump "<<x<<" "<<fa[x][i]<<" "<<w[x][i]<<endl;
			res+=w[x][i];
			x=fa[x][i];
		}
	}
//	cout<<"jd "<<res<<" "<<x<<" "<<y<<endl;
	if(x==y) return res;
	for(int i=16;i>=0;--i){
		if(fa[x][i]!=fa[y][i]){
			res+=w[x][i]+w[y][i];
			x=fa[x][i];
			y=fa[y][i];
		}
	}
	if(x==y) return res;
	return res+w[x][0]+w[y][0];
}
vector<int>g;
bool vis[100001];
signed main(){
//	freopen("game1.in","r",stdin);
//	freopen("out.out","w",stdout);
	read(n,m);
	function<void(int,int,int)>f=[](int x,int y,int z){e[x].push_back({y,z});e[y].push_back({x,z});};
	int x,y,z;readact(n-1,f,x,y,z);
	dfs(1,0,0,1);
	while(m--){
		read(x);
		if(!vis[x]){
			vis[x]=true;
			g.push_back(x);
		}
		else{
			vis[x]=false;
			sort(g.begin(),g.end());
			g.erase(lower_bound(g.begin(),g.end(),x));
		}
		sort(g.begin(),g.end(),[](int a,int b){return dfn[a]<dfn[b];});
		int ans=0;
//		cout<<"g:";
//		for(int i:g)cout<<i<<" ";cout<<endl;
		for(int i=0;i<=(int)g.size()-2;++i){
//			cout<<g.size()-2<<endl;
//			cout<<g.size()<<"act "<<i<<endl;
			ans+=lca(g[i],g[i+1]);
		}
		ans+=lca(g.front(),g.back());
		printf("%lld\n",ans);
	}
}

需要注意的是这里这个 size()-2 一定要强转，这玩意是 unsigned 减不成负数，直接给我 for 循环搞炸了.

然后我们来考虑正解. 注意到题目中每次询问只改变一个点这条性质我们还没用到，考虑改变一个点会对答案有什么影响.

假设我们要加入一个点 \(x\)，距离 \(x\) 的 DFS 序最近的左右两个标记点分别是 \(y,z\)，可以发现，加入前这一段是 \(dist(y,z)\)，加入后会变成 \(dist(y,x)+dist(x,z)\)，因此贡献即为 \(dist(y,x)+dist(x,z)-dist(y,z)\)，同理，删除点的话就变成减去. 这样我们就把更新答案的复杂度变成 \(\log n\) 了.

做这个题的时候，调 STL 调的很难受，STL 的迭代器确实动不动就 RE

#include<bits/stdc++.h>
using namespace std;
#define int long long
namespace reader{
	template<typename T>
	inline void read(T& x){
		x=0;bool sym=0;char c=getchar();
	    while(!isdigit(c)){sym^=(c=='-');c=getchar();}
	    while(isdigit(c)){x=x*10+c-48;c=getchar();}
	    if(sym)x=-x;
	}
	template<size_t N>
	inline void read(char (&str)[N]){
	    size_t n=0;char c=getchar();
	    while(n<N-1&&!isspace(c)){str[n]=c;c=getchar();++n;}
	    str[n]=0;
	}
	template<typename T,size_t N>
	inline void read(T (&a)[N],int range=N){
		for(int i=1;i<=range;++i){read(a[i]);}
	}
	template<typename T,typename... Args>
	inline void read(T& x,Args&... args){
	    read(x);read(args...);
	}
	template<typename T,typename T2>
	inline void readarray(T& x,T2& args){
		read(x);read(args,x);
	}
	template<typename func,typename... Args>
	inline void readact(int x,function<func>fu,Args&... args){
		for(int i=1;i<=x;++i){
			read(args...);
			fu(args...);
		}
	}
}
using namespace reader;
int n,m;
int fa[100001][17];
int w[100001][17];
struct edge{
	int to,w;
};
int deep[100001],dfn[100001],redfn[100001],dfncnt;
vector<edge>e[100001];
void dfs(int now,int last,int lastw,int nowdeep){
	dfn[now]=++dfncnt;
	redfn[dfncnt]=now;
	deep[now]=nowdeep;
	fa[now][0]=last;
	w[now][0]=lastw;
	for(int i=1;i<=16;++i){
		fa[now][i]=fa[fa[now][i-1]][i-1];
		w[now][i]=w[fa[now][i-1]][i-1]+w[now][i-1];
	}
	for(edge i:e[now]){
		if(i.to!=last){
			dfs(i.to,now,i.w,nowdeep+1);
		}
	}
}
int lca(int x,int y){
//	cout<<"lca "<<x<<" "<<y<<endl;
	if(deep[x]<deep[y]) swap(x,y);
	int res=0;
	for(int i=16;i>=0;--i){
		if(deep[x]-deep[y]>=(1<<i)){
//			cout<<"jump "<<x<<" "<<fa[x][i]<<" "<<w[x][i]<<endl;
			res+=w[x][i];
			x=fa[x][i];
		}
	}
//	cout<<"jd "<<res<<" "<<x<<" "<<y<<endl;
	if(x==y) return res;
	for(int i=16;i>=0;--i){
		if(fa[x][i]!=fa[y][i]){
			res+=w[x][i]+w[y][i];
			x=fa[x][i];
			y=fa[y][i];
		}
	}
	if(x==y) return res;
	return res+w[x][0]+w[y][0];
}
//vector<int>g;
bool vis[100001];
std::set<int> s;
std::set<int>::iterator it;
signed main(){
//	freopen("game1.in","r",stdin);
//	freopen("out.out","w",stdout);
	read(n,m);
	function<void(int,int,int)>f=[](int x,int y,int z){e[x].push_back({y,z});e[y].push_back({x,z});};
	int x,y,z;readact(n-1,f,x,y,z);
	dfs(1,0,0,1);int ans=0;
	while(m--){
		read(x);x=dfn[x];
		if(!vis[redfn[x]]){
			s.insert(x);
//			g.push_back(x);
		}
		int y=redfn[(it=s.lower_bound(x))==s.begin()?(*--s.end()):*(--it)];
		int z=redfn[(it=s.upper_bound(x))==s.end()?*s.begin():*it];
//		sort(g.begin(),g.end(),[](int a,int b){return dfn[a]<dfn[b];});
//		auto ity=lower_bound(g.begin(),g.end(),dfn[x],[](int a,int b){return dfn[a]<dfn[b];});
//		auto itz=upper_bound(g.begin(),g.end(),dfn[x],[](int a,int b){return dfn[a]<dfn[b];});
//		int y=((ity==g.begin())?g.back():*--ity);
//		int z=((itz==g.end())?*g.begin():*itz);
		if(vis[redfn[x]]){
			s.erase(x);
//			g.erase(lower_bound(g.begin(),g.end(),dfn[x]));
		}
		x=redfn[x];
		if(vis[x]){
			vis[x]=false;
			ans-=lca(x,y)+lca(x,z)-lca(y,z);
		}
		else{
			vis[x]=true;
			ans+=lca(x,y)+lca(x,z)-lca(y,z);
		}
		printf("%lld\n",ans);
	}
}