点分治题目

tree

思路：要求出树上小于w的链的个数，与求出是否有等于的个数相似，用两个指针在数组上查找，如果查到两个点(l与r)符合要求，那么l与k(l<k<=r&&id[l]!=id[k])一定符合要求。先记录一个数组(cnt)来维护l+1~r中间有多少id和点l的id相等,答案再加上r-l-cnt

#include<bits/stdc++.h>
using namespace std;
struct node{
	int p,w;
	node(int x,int y){
		p=x;
		w=y;
	}
};

vector<node>tu[40010];
bool vis[40010];
int a,b,root,root_ans[40010],shu[40010],d[40010],id[40010],sz[40010],cnt[40010],ans,tot;
int cmp(int x,int y){
	return d[x]<d[y];
}
int read();
void get_root(int x,int fa,int total);
void get_d(int x,int fa,int dis,int from);
void get_ans(int x);
void dfs(int x);
int main(){
	a=read();
	for(int i=1;i<a;i++){
		int o,k,w;
		o=read();k=read();w=read();
		tu[o].push_back(node(k,w));
		tu[k].push_back(node(o,w)); 
	}
	b=read();
	get_root(1,-1,a);
	dfs(root);
	cout<<ans;
	return 0;
}
void get_root(int x,int fa,int total){
	sz[x]=1;
	root_ans[x]=0;
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i].p;
		int w=tu[x][i].w;
		if(p==fa||vis[p]) continue;
		get_root(p,x,total);
		sz[x]+=sz[p];
		root_ans[x]=max(root_ans[x],sz[p]);
	}
	root_ans[x]=max(root_ans[x],total-sz[x]);
	if(!root||root_ans[x]<root_ans[root]){
		root=x;
	}
}
void get_d(int x,int fa,int dis,int from){
	shu[++tot]=x;
	d[x]=dis;
	id[x]=from;
	cnt[id[x]]++;//记录所有的id出现次数
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i].p;
		int w=tu[x][i].w;
		if(vis[p]||p==fa) continue;
		get_d(p,x,dis+w,from);
	} 
}
void get_ans(int x){
	tot=0;
	shu[++tot]=x;
	d[x]=0;
	id[x]=x;
	cnt[x]=1;
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i].p;
		int w=tu[x][i].w;
		if(vis[p]) continue;
		cnt[p]=0;
		get_d(p,x,w,p);
	}
	sort(shu+1,shu+tot+1,cmp);

		int l=1,r=tot;
		
		while(l<r){
			if(d[shu[l]]+d[shu[r]]>b){
				cnt[id[shu[r]]]--;//不符合情况的时候指针移动，颜色数修改
				r--;
			}else{
			/*	if(id[shu[l]]==id[shu[r]]){
					if(d[shu[r-1]]==d[shu[r]]){
						cnt[id[shu[r]]]--;
						r--;
					}else{
						cnt[id[shu[l]]]--;
						l++;
					}
				}else{*/
					cnt[id[shu[l]]]--;
					ans=ans+r-l-cnt[id[shu[l]]];
					l++;
				//}
			}
		}

}
void dfs(int x){
	vis[x]=true;
	get_ans(x);
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i].p;
		if(vis[p]) continue;
		root=0;
		get_root(p,x,sz[p]);
		dfs(root);
	}
}

int read(){
	int a=0,b=1;
	char ch=getchar();
	while((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
	if(ch=='-'){
		b=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		a=a*10+ch-'0';
		ch=getchar();
	}
	return a*b;
}

race

思路：与题解上的不太一样，可以先用点分治处理出来所有等于w的数量，然后再对于每对(from,to)做树上的lca计算路径上的边的条数更新答案

#include<bits/stdc++.h>
using namespace std;
struct node{
	int p,w;
	node(int x,int y){
		p=x;
		w=y;
	}
}; 
vector<node>tu[200010];
struct k{
	int from,to;
};
k ans[200110];
int ans_cnt;
int d[200010],id[200010],num[200010],sz[200010],root,root_ans[200010],a,w,cnt,lca_d[200010],lca_fa[200010][22],ty=0x3f3f3f3f;
bool vis[200010];
int cmp(int x,int y){
	return d[x]<d[y];
}
map<int,map<int,int> >mp;
int read();
void get_root(int x,int fa,int s);
void get_d(int x,int fa,int dis,int from);
void get_ans(int x);
void dfs(int x);

void lca_dfs(int x,int fa);
void lca_init();
int lca(int x,int y);
int main(){
	a=read();w=read();
	for(int i=1;i<a;i++){
		int o,k,ww;
		o=read();k=read();ww=read();
		o++;
		k++;
		tu[o].push_back(node(k,ww));
		tu[k].push_back(node(o,ww)); 
	}
	get_root(1,-1,a);
	dfs(root);
	if(!ans_cnt){
		cout<<-1;
		return 0;
	}
	lca_init();
	return 0;
}
void get_root(int x,int fa,int s){
	sz[x]=1;
	root_ans[x]=0;
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i].p;
		if(vis[p]||p==fa) continue;
		get_root(p,x,s);
		sz[x]+=sz[p];
		root_ans[x]=max(root_ans[x],sz[p]);
	}
	root_ans[x]=max(root_ans[x],s-sz[x]);
	if(!root||root_ans[x]<root_ans[root]){
		root=x;
	}
}
void get_d(int x,int fa,int dis,int from){
	d[x]=dis;
	id[x]=from;
	num[++cnt]=x;
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i].p;
		int w=tu[x][i].w;
		if(vis[p]||p==fa) continue;
		get_d(p,x,dis+w,from);
	}
}
void get_ans(int x){
	d[x]=0;
	id[x]=x;
	cnt=0;
	num[++cnt]=x;
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i].p;
		int w=tu[x][i].w;
		if(vis[p]) continue;
		get_d(p,x,w,p);
	}
	sort(num+1,num+cnt+1,cmp);
	int l=1,r=cnt;
	while(l<r){
		if(d[num[l]]+d[num[r]]>w){
			r--;
			continue;
		}
		if(d[num[l]]+d[num[r]]<w){
			l++;
			continue;
		}
		
		if(id[num[l]]==id[num[r]]){
		 l++;
			continue;
		}
		if(!mp[num[l]][num[r]]){//每一次遇到符合条件的点对，先判断以前是否记录过，然后再记录上
			mp[num[l]][num[r]]=true;
			ans_cnt++;
			ans[ans_cnt].from=num[l];
			ans[ans_cnt].to=num[r];
             l++;
		}else{
		 l++;
		}
	}
}
void dfs(int x){
	vis[x]=true;
	get_ans(x);
	
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i].p;
		if(vis[p]) continue;
		root=0;
		get_root(p,x,sz[p]);
		dfs(root);
	}
}
void lca_dfs(int x,int fa){
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i].p;
		int w=tu[x][i].w;
		if(p==fa) continue;
		lca_d[p]=lca_d[x]+1;
		lca_fa[p][0]=x;
		lca_dfs(p,x);
	}
}
int lca(int x,int y){
	if(lca_d[x]<lca_d[y]) swap(x,y);
//	cout<<"*"<<lca_d[x]<<"  "<<lca_d[y]<<endl;
	int ans=0;
	int k=0;
	while((1<<(k+1))<=lca_d[x]) k++;
	for(int i=k;i>=0;i--){
		if(lca_d[lca_fa[x][i]]>=lca_d[y]){
			ans+=(1<<i);
			x=lca_fa[x][i];
		}
	}
	
	if(x==y) return ans;
	for(int i=k;i>=0;i--){
		if(lca_fa[x][i]!=lca_fa[y][i]){
			ans+=(1<<i);
			ans+=(1<<i);
			x=lca_fa[x][i];
			y=lca_fa[y][i];
		}
	}
	ans+=2;
//	cout<<lca_fa[x][0]<<" "<<lca_fa[y][0]<<endl;
	return ans;
}
void lca_init(){
	lca_d[1]=1;
	lca_dfs(1,-1);
	for(int i=1;(1<<i)<=a;i++){
		for(int j=1;j<=a;j++){
			lca_fa[j][i]=lca_fa[lca_fa[j][i-1]][i-1];
		}
	}
	for(int i=1;i<=ans_cnt;i++){
		int p1=ans[i].from;
		int p2=ans[i].to;
		ty=min(ty,lca(p1,p2));//每次求出两点的距离更新答案
	}
	printf("%d\n",ty);
	
}

int read(){
	int a=0,b=1;
	char ch=getchar();
	while((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
	if(ch=='-'){
		b=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		a=a*10+ch-'0';
		ch=getchar();
	}
	return a*b;
}