树刷题笔记

• 树的直径
• 树的中心
• 树的重心
• 洛谷P3398(点和路径关系，LCA)
• 洛谷P4281(枚举，LCA)
• 洛谷P5588(树状数组，LCA，思维)
• 洛谷P5536核心城市(树的中心，贪心)
• 洛谷P1273有线电视网(树形DP，分组背包)
• HDU6035Colorful tree(思维好题)

树的直径

定义：树中最长的链叫直径
求法：同时维护每个节点到子叶子结点的最长链和次长链，然后答案就是max(longest[i]+second_longest[i])(i=1,2...n)

int ml[N],sl[N];
int dfs(int son,int dad)
{
   for(auto v:eg[son])
      {
            if(v==dad) continue;
            int l=dfs(son,dad);
            if(l>ml[son]) swap(ml[son],l);
            if(l>sl[son]) swap(sl[son],l);
      }   
   ans=max(ans,sl[son]+ml[son]);
   return ml[son]+len(边长);
}

树的中心

定义：到所有点的最长距离最小的点叫做树的中心
一个结论：从起点开始遍历，这颗树的中心一定存在于重链上（同树链刨分）
求法：先给出一些定义：

struct Max_node{
      int v,w;
}sl[N],ml[N];

ml[i]记录到子叶节点的最长路，sl则是次长路，求法如代码

void dfs1(int x,int y)//预处理Mt1和Mt2的内容
{
    for(auto mv:eg[x])if(mv.first!=y){
        int v=mv.first,w=mv.second;
        dfs1(v,x);
        Max_node temp(v,ml[v].w+w);
        if(temp.w>ml[x].w) swap(ml[x],temp);
        if(temp.w>sl[x].w) swap(sl[x],temp);
    }
}
void dfs2(int x,int y,int len,int Max_up)//遍历更新答案
{
    int Max=max(Mt1[x].w,Max_up);//计算该节点的延伸出去的最长路径
    if(Max<ans_w) ans_v=x,ans_w=Max;//更新答案
    if(Max_up>Mt1[x].w) return ;//如果最长路径是往上的，说明没必要往下了，理由同上
    for(auto mv:eg[x])if(mv.first==Mt1[x].v) dfs2(mv.first,x,mv.second,max(sl[x].w,Max_up)+mv.second);
}

树的重心

定义：使得连接自身最大子树最小的点
求法：简单随便求

int siz[N];
void dfs(int s,int d)
{
      siz[s]=1;
      int Max=0;
      for(auto v:eg[s])if(v!=d)
      {
            dfs(v,s);
            siz[s]+=siz[v];
            Max=max(siz[v],Max);
      }
      Max=max(n-siz[s],Max);
      if(Max>Ans_w) Ans_w=Max,Ans_v=s;
}

洛谷P3398仓鼠找Suger

题意：n节点的树，q次询问，每次给出两条路径(给出路径的方式是给出起点和终点)，问这两条是否有公共点。(n,q<=1e5)

解答：

一个结论：
如果俩路径相交，则 ab 的 LCA 在 cd 上或者 cd 的 LCA 在 ab 上
另一个结论：
如果一个点在一个路径上，则这个点和另外两个点的LCA分别是这个点和路径的LCA
此题结束

//验证点是否在路径上 
#include<bits/stdc++.h>
using namespace std;
#define f(i,a,b) for(register int i=a;i<=b;++i)
#define ll long long
#define N 100005
inline int read(){int x;scanf("%d",&x);return x;}
vector<int>eg[N];
int fa[N][25],deep[N];
void dfs(int s,int d)
{
	deep[s]=deep[d]+1;
	fa[s][0]=d;
	for(auto v:eg[s])if(v!=d){
		dfs(v,s);
	}
}
void init(int n)
{
	for(int j=1;j<=20;++j)
		for(int i=1;i<=n;++i)
			fa[i][j]=fa[fa[i][j-1]][j-1];
}
int LCA(int a,int b)
{
	if(deep[a]<deep[b]) swap(a,b);
	for(int j=20;j>=0;--j) if(deep[fa[a][j]]>=deep[b]) a=fa[a][j];
	if(a==b) return a;
	for(int j=20;j>=0;--j) if(fa[a][j]!=fa[b][j]) a=fa[a][j],b=fa[b][j];
	return fa[a][0];
}
bool In_Road(int x,int a,int b,int y)
{
	if(x==a||x==b||x==y) return true;
	int l1=LCA(x,a),l2=LCA(x,b);
	if(l1==x&&l2==y) return true;
	if(l1==y&&l2==x) return true;
	return false;
}
void solve()
{
	int n=read(),q=read();
	f(i,1,n-1) 
	{
		int a=read(),b=read();
		eg[a].push_back(b);
		eg[b].push_back(a);
	}
	dfs(1,0);
	init(n);
	f(i,1,q)
	{
		int a=read(),b=read(),c=read(),d=read();
		int la1=LCA(a,b),la2=LCA(c,d);
		if(In_Road(la1,c,d,la2)||In_Road(la2,a,b,la1)) printf("Y\n");
		else printf("N\n");
	}
}
int main()
{
	int T=1;
	while(T--) solve();
	return 0;	
}

洛谷P4281紧急集合

题意：给一颗n节点的树，m次询问，每次给出三个节点a，b，c求一点d，使得a，b，c到d距离总和最小(n,m<5e5)
解答：在枚举三个节点个各种情况后发现，可以简化成两种情况
1：两两求LCA后的三个LCA都一样，则这个LCA就是所求的点
2：求出的三个LCA两个一样，则不一样的那个LCA就是所求的点
每种情况求三次LCA，复杂度O(mlogn),常数为3

//验证点是否在路径上 
#include<bits/stdc++.h>
using namespace std;
#define f(i,a,b) for(register int i=a;i<=b;++i)
#define ll long long
#define N 500005
inline int read(){int x;scanf("%d",&x);return x;}
vector<int>eg[N];
int fa[N][25],deep[N];
void dfs(int s,int d)
{
	deep[s]=deep[d]+1;
	fa[s][0]=d;
	for(auto v:eg[s])if(v!=d){
		dfs(v,s);
	}
}
void init(int n)
{
	for(int j=1;j<=20;++j)
		for(int i=1;i<=n;++i)
			fa[i][j]=fa[fa[i][j-1]][j-1];
}
int LCA(int a,int b)
{
	if(deep[a]<deep[b]) swap(a,b);
	for(int j=20;j>=0;--j) if(deep[fa[a][j]]>=deep[b]) a=fa[a][j];
	if(a==b) return a;
	for(int j=20;j>=0;--j) if(fa[a][j]!=fa[b][j]) a=fa[a][j],b=fa[b][j];
	return fa[a][0];
}
bool In_Road(int x,int a,int b,int y)
{
	if(x==a||x==b||x==y) return true;
	int l1=LCA(x,a),l2=LCA(x,b);
	if(l1==x&&l2==y) return true;
	if(l1==y&&l2==x) return true;
	return false;
}
int Abs(int x){
	if(x<0) return -x;
	return x;
}
void solve()
{
	int n=read(),q=read();
	f(i,1,n-1) 
	{
		int a=read(),b=read();
		eg[a].push_back(b);
		eg[b].push_back(a);
	}
	dfs(1,0);
	init(n);
	f(i,1,q)
	{
		int a=read(),b=read(),c=read();
		int la1=LCA(a,b),la2=LCA(b,c),la3=LCA(a,c);
		if(la1==la2&&la2==la3)
			printf("%d %d\n",la1,deep[a]+deep[b]+deep[c]-3*deep[la1]);
		else{
			if(la1==la2) 
				printf("%d %d\n",la3,Abs(deep[la3]-deep[a])+Abs(deep[la3]-deep[c])+Abs(deep[la1]-deep[la3])+Abs(deep[la1]-deep[b]));
			else if(la2==la3) 
				printf("%d %d\n",la1,Abs(deep[la1]-deep[a])+Abs(deep[la1]-deep[b])+Abs(deep[la1]-deep[la3])+Abs(deep[la2]-deep[c]));
			else 
				printf("%d %d\n",la2,Abs(deep[la2]-deep[b])+Abs(deep[la2]-deep[c])+Abs(deep[la1]-deep[la2])+Abs(deep[la1]-deep[a]));
		}
	}
}
int main()
{
	int T=1;
	while(T--) solve();
	return 0;	
}

洛谷P5588小猪佩奇爬树

题意：给一颗n节点树，每个节点有一个颜色，求对每个颜色有多少条长度大于一的路径包含了所有该颜色
解答：定义一个cnt[i]数组，记录遍历当前点的时候i颜色出现的次数，假设颜色i的一个“极低点”代表该点颜色为i且的子节点中没有颜色i的点，稍加分析可以得出，对于颜色i
1：有1个极低点时，颜色i所有点都是极低点的祖先节点，形成一条链，只要记录最高点位置，就能轻易求出路径数
2：有两个极低点时，如果颜色i的最高点不在两个极低点的路径上时，就形成一条以两个极低点为端点的链，否则路径不存在
3：极低点大于3时，路径不存在

PS：只有一个点时要特判

//验证点是否在路径上 
#include<bits/stdc++.h>
using namespace std;
#define f(i,a,b) for(register int i=a;i<=b;++i)
#define ll long long
#define N 1000050
#define pb push_back
inline ll read(){ll x;scanf("%lld",&x);return x;}
vector<ll>eg[N],vex[N],temp;
ll fa[N][25],deep[N],co[N],cnt[N],Ans[N],hst[N],siz[N];
void dfs(ll s,ll d)
{
	siz[s]=1;
	deep[s]=deep[d]+1;
	if(!hst[co[s]]) hst[co[s]]=s;
	fa[s][0]=d;
	for(auto v:eg[s])if(v!=d){
		dfs(v,s);
		siz[s]+=siz[v];
	}
}
void init(ll n)
{
	for(int j=1;j<=20;++j)
		for(int i=1;i<=n;++i)
			fa[i][j]=fa[fa[i][j-1]][j-1];
}
ll LCA(ll a,ll b)
{
	if(deep[a]<deep[b]) swap(a,b);
	for(int j=20;j>=0;--j) if(deep[fa[a][j]]>=deep[b]) a=fa[a][j];
	if(a==b) return a;
	for(int j=20;j>=0;--j) if(fa[a][j]!=fa[b][j]) a=fa[a][j],b=fa[b][j];
	return fa[a][0];
}
bool In_Road(ll x,ll a,ll b,ll y)
{
	if(x==a||x==b||x==y) return true;
	ll l1=LCA(x,a),l2=LCA(x,b);
	if(l1==x&&l2==y) return true;
	if(l1==y&&l2==x) return true;
	return false;
}
ll find_fa(ll u,ll v)
{
	for(int j=20;j>=0;--j) if(deep[fa[u][j]]>deep[v]) u=fa[u][j];
	return u;
}
void dfs2(ll s,ll d)
{
	ll now=cnt[co[s]];
	for(auto v:eg[s])if(v!=d){
		dfs2(v,s);
	}
	if(now==cnt[co[s]]) vex[co[s]].pb(s);
	++cnt[co[s]];
}
void solve()
{
	ll n=read();
	f(i,1,n) co[i]=read();
	f(i,1,n-1)
	{
		ll a=read(),b=read();
		eg[a].pb(b);
		eg[b].pb(a);
	}
	dfs(1,0);
	init(n);
	dfs2(1,0);
	f(i,1,n)
	{
		if(vex[i].empty()) Ans[i]=(n-1)*n/2;
		else if(vex[i].size()==1)
		{
			ll v=hst[i];
			if(v==vex[i][0])
			{
				temp.clear();
				for(auto u:eg[v])if(u!=fa[v][0]) temp.pb(u);
				ll sum=0,sie=temp.size();
				f(i,0,sie-1) f(j,i+1,sie-1) sum+=siz[temp[i]]*siz[temp[j]];
				sum+=siz[v]*(n-siz[v]+1)-1;
				Ans[i]=sum;
			}
			else
			{
				ll u=find_fa(vex[i][0],v);
				Ans[i]=siz[vex[i][0]]*(n-siz[u]);
			}
		}
		else if(vex[i].size()==2)
		{
			ll u=hst[i];
			if(!In_Road(u,vex[i][0],vex[i][1],LCA(vex[i][0],vex[i][1]))) continue;
			Ans[i]=siz[vex[i][0]]*siz[vex[i][1]];
		}
		else Ans[i]=0;
	}
	f(i,1,n) printf("%lld\n",Ans[i]);
}
int main()
{
	int T=1;
	while(T--) solve();
	return 0;	
}

洛谷P5536核心城市

题意：给一个n节点的树，选k个核心点（k个核心点必须在同一个连通块），使得非核心点到最近的核心点最大的距离最小
解答：[贪心]先求出直径的中点，即中心，可以知道这个点一定在核心点中(假设不在，那最终非核心点距离最近的核心点一定大于L/2(L为直径)，与中心是核心点时最大距离为L/2相悖，因此第一个点选这个点准没错)。
然后，设与中心相邻的点为vi，下一个点就选max（vi|Li最大）（Li代表vi可延伸出去的最大距离）。（证明：如果不选这个点，非核心点到核心点的距离一定大于max（Li），选了有可能会变小，因此选它准没错）

//验证点是否在路径上 
#include<bits/stdc++.h>
using namespace std;
#define f(i,a,b) for(register int i=a;i<=b;++i)
#define ll long long
#define N 100050
#define pb push_back
inline int read(){int x;scanf("%d",&x);return x;}
vector<int>eg[N];
struct Max_node{
	int v,w;
	Max_node(int vv=0,int ww=0):v(vv),w(ww){}
}ml[N],sl[N];
int mv[N],vis[N];
void dfs1(int s,int d)
{
	mv[s]=1;
	for(auto v:eg[s])if(v!=d)
	{
		dfs1(v,s);
		mv[s]=max(mv[v]+1,mv[s]);
		Max_node temp(v,mv[v]);
		if(temp.w>ml[s].w) swap(temp,ml[s]);
		if(temp.w>sl[s].w) swap(temp,sl[s]); 
	}
}
int Ans_v,Ans_w=9999999;
void dfs2(int s,int up)
{
	int Max=0;
	if(ml[s].w>up) 
	{
		if(ml[s].w<Ans_w) Ans_w=ml[s].w,Ans_v=s;
	} 
	else
	{
		if(up<Ans_w) Ans_w=up,Ans_v=s;return ;
	}
	if(ml[s].v) dfs2(ml[s].v,max(up+1,sl[s].w+1));
}
int lgst[N];
void dfs3(int s,int d)
{
	lgst[s]=1;
	for(auto v:eg[s])if(v!=d){
		dfs3(v,s);
		lgst[s]=max(lgst[s],lgst[v]+1);
	}
}
struct Node{
	int v,w;
	Node(int vv,int ww):v(vv),w(ww){}
	friend bool operator<(Node a,Node b){
		return a.w<b.w;
	}
};
priority_queue<Node>qn;
void solve()
{
	int n=read(),k=read();
	f(i,1,n-1)
	{
		int a=read(),b=read();
		eg[a].pb(b);
		eg[b].pb(a);
	}
	dfs1(1,0);
	dfs2(1,0);
	dfs3(Ans_v,0);
	qn.push(Node(Ans_v,lgst[Ans_v]));
	while(k--)
	{
		int v=qn.top().v;
		vis[v]=1;
		qn.pop();
		for(auto u:eg[v]) if(!vis[u]) qn.push(Node(u,lgst[u]));
	}
	printf("%d\n",qn.top().w);
}
int main()
{
	int T=1;
	while(T--) solve();
	return 0;	
}

洛谷P1273有线电视网

题意：给一颗n节点有权树（每条边都有个权值），树的每个叶子节点都有一个贡献，当选取几个叶子结点时，会得到的分数为（叶子结点贡献和）-（根节点到这些叶子结点的权值和），问满足分数不为负的情况下，最多能选择多少叶子结点。
题解：dp[i][j]代表以i为根节点的子树选j个叶子结点得到的最多分数。根节点与子节点形成分组背包，但是有一些细节处理，比如dp数组要初始化为负无穷。

#include<bits/stdc++.h>
using namespace std;
#define f(i,a,b) for(register int i=a;i<=b;++i)
#define ll long long
#define N 3505
#define INF 999999999
#define pb push_back
#define mp make_pair
#define fi first
#define se second
inline ll read(){ll x;scanf("%lld",&x);return x;}
vector<pair<int,int> >eg[N];
int siz[N],dp[N][N];
void dfs1(int s,int d)
{
	if(siz[s]==1) return ;
	for(auto pv:eg[s])
	{
		int v=pv.fi;
		dfs1(v,s);
		siz[s]+=siz[v];
	}
}
void dfs2(int s,int d)
{
	for(auto pv:eg[s])
	{
		int v=pv.fi,w=pv.se;
		dfs2(v,s);
		for(int i=siz[s];i>=0;--i)
			for(int k=0;k<=siz[v]&&k<=i;++k)
				dp[s][i]=max(dp[s][i],dp[s][i-k]+dp[v][k]-w);
	}
}
void solve()
{
	int n=read(),m=read();
	f(i,1,n-m)
	{
		int k=read();
		f(j,1,k) eg[i].pb(mp(read(),read()));
	}
	f(i,1,n) f(j,1,n) dp[i][j]=-INF;
	f(i,n-m+1,n) dp[i][1]=read(),siz[i]=1;
	dfs1(1,0);
	dfs2(1,0);
	for(int i=siz[1];i>=0;--i) if(dp[1][i]>=0){
		cout<<i<<endl;
		return ;
	}
}
int main()
{
	ll T=1;
	while(T--) solve();
	return 0;
} 

HDU6035Colorful tree

题意：给一颗n节点树，每个节点有一个颜色（范围在1-n），求所有路径经过颜色种类数的和，即求:
\(\sum_{i=0}^n\)\(\sum_{j=1}^n{Color(i,j)}\)(其中Color(i,j)代表路径ij上的颜色有几种)
题解：求每条路径的颜色数等价于求每种颜色有几条路径经过的数量和，再将每种颜色经过的路径数转化成每种颜色有几条路径没经过，一次dfs可解。

#include <bits/stdc++.h>
using namespace std;
#define f(i,a,b) for(register int i=a;i<=b;++i)
#define N 100005
#define ll long long
inline ll read(){ll x;scanf("%lld",&x);return x;}
ll sum[N],color[N],siz[N];
vector<ll>eg[N];
ll ans;
void DFS(ll s,ll d)
{
	siz[s]=1;
	for(ll v:eg[s]) if(v!=d)
	{
		ll last = sum[color[s]];
		DFS(v,s);
		siz[s]+=siz[v];
		ll now = sum[color[s]];
		ll d1=now-last,d2=siz[v]-d1;
		ans=(ans+d2*(d2-1)/2);
		sum[color[s]]+=d2; 
	}
	sum[color[s]]++;
}
int main() 
{
	ll n,Cas=0;
    while(~scanf("%lld",&n))
    {
    	++Cas;
    	ans=0;
    	memset(sum,0,sizeof sum);
    	f(i,1,n) color[i]=read(),eg[i].clear();
    	f(i,1,n-1)
    	{
    		ll x=read(),y=read();
    		eg[x].push_back(y);
    		eg[y].push_back(x);
		}
		DFS(1,0);
		f(i,1,n) ans+=(n-sum[i])*(n-sum[i]-1)/2;
		ans=n*n*(n-1)/2-ans;
		printf("Case #%lld: %lld\n",Cas,ans);
	}
    return 0;
}