洛谷 【图论1】基础树上问题

题单链接

P5836 [USACO19DEC]Milk Visits S【并查集】

• 并查集。合并的条件是：相邻并且颜色相同才合并。
• 判断是否高兴的条件是，（1）端点所处的并查集不同或者（2）并查集相同，端点的奶牛种类符合预期。

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1e5+10;
int n,m,par[maxn],x,y;char c[maxn],z;
void init(){
	for(int i=1;i<=n;i++) par[i]=i;
}
int find(int x){
	if(par[x]==x) return x;
	return par[x]=find(par[x]);
}
void unit(int x,int y){
	x=find(x),y=find(y);
	if(c[x]==c[y]){
		par[x]=y;
	}
}
int main(){
	cin>>n>>m;cin.get();
	init(); 
	for(int i=1;i<=n;i++)c[i]=cin.get();
	for(int i=1;i<=n-1;i++){
		cin>>x>>y;
		unit(x,y);
	}
	for(int i=1;i<=m;i++){
		cin>>x>>y>>z;
		cout<<(find(x)!=find(y)||c[x]==z);
	} 
}

P3629 [APIO2010]巡逻【树的直径】

• 设新建1条路之后环的长度为$L$(不含新建的路),那么走的总长度变为$2(n-1)-L+1$，由此看出要求树的直径。

• 当新建2条路之后，每一条边需要走的次数如下：
  ·一条边仅在第2个环出现过，只用走1次
  · 一条边在两个环都出现过，要走2次
  ·一条边在两个环都没出现过，要走2次

• 因为当一条边属于2个环时要走2次，所以在第2次求树的直径时将第1条书的直径的边的权值改为$-1$.

• DP求树的直径(可以处理负权值，但只能求直径的长度)：设$dp[u]$表示从结点u出发向u的子树走能走到的最远距离，$v$为$u$的子节点，$dp[u]=max(dp[v]+dis(u,v))$.直径的两个端点可能属于$u$的两棵不同的子树，也可能在一棵子树内。

void dp(int x){
	vis[x]=1;
	for(int i=head[x];i;i=e[i].next){
		int y=e[i].to;
		if(vis[y]) continue;
		dp(y);
		ans=max(ans,dis[x]+dis[y]+e[i].w);
		dis[x]=max(dis[x],dis[y]+e[i].w); 
	}
}

• 树的遍历求直径，不能处理负权值，但是可以记录直径的端点。

void bfs(int x,int opt){
	memset(dis,0,sizeof dis);
	memset(vis,0,sizeof vis);
	while(q.size())q.pop();
	q.push(x);vis[x]=1;
	while(q.size()){
		int now=q.front();q.pop();
		for(int i=head[now];i;i=e[i].next){
			int y=e[i].to;
			if(!vis[y]){
				vis[y]=1;
				dis[y]=dis[now]+e[i].w;
				q.push(y);
				if(opt) fa[y]=now;
			}
		}
	}
	for(int i=1;i<=n;i++){
		if(ans<dis[i]) ans=dis[i],v1=i;
	} 	
}

• 解题代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N=1e5+10;
int n,head[N],tot,dis[N],vis[N],fa[N],ans,v1,k;
queue<int> q;
struct Edge{
	int to,w,next;
}e[2*N]; 
void add(int u,int v,int w){
	e[++tot].to=v;
	e[tot].w=w;
	e[tot].next=head[u];
	head[u]=tot;
}
void bfs(int x,int opt){
	memset(dis,0,sizeof dis);
	memset(vis,0,sizeof vis);
	while(q.size())q.pop();
	q.push(x);vis[x]=1;
	while(q.size()){
		int now=q.front();q.pop();
		for(int i=head[now];i;i=e[i].next){
			int y=e[i].to;
			if(!vis[y]){
				vis[y]=1;
				dis[y]=dis[now]+e[i].w;
				q.push(y);
				if(opt) fa[y]=now;
			}
		}
	}
	for(int i=1;i<=n;i++){
		if(ans<dis[i]) ans=dis[i],v1=i;
	} 	
}
void change(int x){
	while(fa[x]){
		int father=fa[x];
		for(int i=head[father];i;i=e[i].next){
			if(e[i].to==x){
				e[i].w=-1;break;
			}
		}
		for(int i=head[x];i;i=e[i].next){
			if(e[i].to==father){
				e[i].w=-1;break;
			}
		}
		x=father;		
	}
}
void dp(int x){
	vis[x]=1;
	for(int i=head[x];i;i=e[i].next){
		int y=e[i].to;
		if(vis[y]) continue;
		dp(y);
		ans=max(ans,dis[x]+dis[y]+e[i].w);
		dis[x]=max(dis[x],dis[y]+e[i].w); 
	}
}
int main(){
	cin>>n>>k;
	for(int i=1;i<n;i++){
		int a,b;
		cin>>a>>b;
		add(a,b,1);add(b,a,1);
	}
	if(k==1){
		bfs(1,0);
		bfs(v1,0);
		cout<<2*n-dis[v1]-1<<endl;
	}
	else{
		bfs(1,0);
		bfs(v1,1);
		int len1=dis[v1];
		change(v1);		
		memset(dis,0,sizeof dis);
		memset(vis,0,sizeof vis);
		ans=0;
		dp(1);
		cout<<2*n-ans-len1<<endl;
	}
}

P1395 会议【树型DP】

• $size[i]$表示$i$于$i$的子树的节点个数之和
• $d[i]$表示当前节点距离1节点的距离（1节点到自己的距离为1，其余节点也要+1，目的是标记1节点已经访问过）
• $f[x]$表示在$i$点开会的距离之和.状态转移方程为，设$y$是$x$的父节点，$f[x]=f[y]+(n-size[x])-size[x]$.意义是（1）对于不在$x$的子树的节点，到$x$的距离等于到$y$的距离+1（2）对于在x的子树的节点，距离等于到$y$的距离-1.

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=5e4+10;
int d[N],f[N],n,tot,size[N],vis[N],head[N];
struct Edge{
	int to,next;
}e[2*N];
void add(int x,int y){
	e[++tot].to=y;
	e[tot].next=head[x];
	head[x]=tot;
} 
void init(int x){
	size[x]=1;
	for(int i=head[x];i;i=e[i].next){
		int y=e[i].to;
		if(d[y]) continue;
		d[y]=d[x]+1;
		init(y);
		size[x]+=size[y];
	}
}
void dfs(int x,int fa){
	f[x]=f[fa]+n-2*size[x];
	for(int i=head[x];i;i=e[i].next){
		int y=e[i].to;
		if(y==fa) continue;
		dfs(y,x); 
	}
}
int main(){
	cin>>n;
	for(int x,y,i=1;i<n;i++){
		cin>>x>>y;
		add(x,y),add(y,x);
	} 
	d[1]=1;//标记1点已经来过 
	init(1);
	int maxn=0,v=1;
	for(int i=1;i<=n;i++) maxn+=d[i];
	maxn-=n; 
	f[1]=maxn;
	for(int i=head[1];i;i=e[i].next){
		int y=e[i].to;
		dfs(y,1);
	}
	for(int i=2;i<=n;i++){
		if(f[i]<maxn) maxn=f[i],v=i;
	}
	cout<<v<<" "<<maxn<<endl;
} 

P5536 【XR-3】核心城市【树的直径】

• 树中的节点$a$,距离他最远的节点是直径的端点，所以最大距离就是$max(dis(a,直径的端点1),dis(a,直径的端点2))$，所以当$a$是直径的中点时，可以保证最大距离最小。
• 记$deep[i]$为在以直径的重点为根的树中，$i$节点的深度，$maxdee[i]$为在以直径的重点为根的树中，$i$节点所能到达的最深的深度。
• $dis[i]=maxdeep[i]-deep[i]$表示离$i$节点树叶方向上的最远的节点。
• 选取直径的中点，前$k-1$个$dis[i]$最大的节点。
• 最终的答案为，非核心城市的$max(dis+1)$.因为$dis[i]$最大，所以一定和核心城市相连，核心城市据最远的节点的距离为$dis[i]+1$.

#include<iostream>
#include<algorithm>
#include<cstring>
#define N 100010
using namespace std;
int n,k,head[N],tot,deep[N],maxdeep[N],diameter,v1,v2,f[N],dis[N],ans;
struct Edge{
	int to,next;
}e[2*N];
void add(int x,int y){
	e[++tot].to=y;
	e[tot].next=head[x];
	head[x]=tot;
}
void dfs(int x,int fa){
	if(deep[x]>diameter){
		diameter=deep[x];
		v1=x;
	}
	for(int i=head[x];i;i=e[i].next){
		int y=e[i].to;
		if(y==fa) continue;
		deep[y]=deep[x]+1;		
		f[y]=x;
		dfs(y,x);
	}
}
void dfs2(int x,int fa){
	maxdeep[x]=deep[x];
	for(int i=head[x];i;i=e[i].next){
		int y=e[i].to;
		if(y==fa) continue;
		deep[y]=deep[x]+1;
		dfs2(y,x);
		maxdeep[x]=max(maxdeep[x],maxdeep[y]);
	}
}
bool cmp(int x,int y){
	return x>y;
}
int main(){
	cin>>n>>k;
	for(int x,y,i=1;i<n;i++){
		cin>>x>>y;
		add(x,y);add(y,x);
	} 
	dfs(1,0);
	memset(deep,0,sizeof deep);
	diameter=0;
	dfs(v1,0);
	int midpoint=v1;
	for(int i=1;i<=(deep[v1]+1)/2;i++){
		midpoint=f[midpoint];
	}
	memset(deep,0,sizeof deep);
	dfs2(midpoint,0);
	for(int i=1;i<=n;i++) dis[i]=maxdeep[i]-deep[i];
	sort(dis+1,dis+1+n,cmp);
	for(int i=k+1;i<=n;i++) ans=max(ans,dis[i]+1);
	cout<<ans<<endl;
}