NOIP2018D2T3 保卫王国

一眼看上去很像动态DP，然而萌新不会，只能看题解写了一个LCA
我们看题目要求求的东西，每次给定两个点，必选或者不选，让你求在这情况下的最小权独立集，我们考虑每次必选或者必不选对整体的影响
只会影响，他俩到LCA和LCA到根的路径，其他都是可以直接调用的
那么我们考虑倍增维护一下每一条链
f[i][j][0/1][0/1] 表示在i点向上跳 2^j 步后 选或不选i 和选或不选fa[i][j] 在这条路上的最小权值
注意不包括i点，但包括路径上的分叉子树
dp[i][0/1]表示在以i为根的子树，i选或者不选的最小值
我们先预处理出来这两个数组

然后考虑如何回答询问，每次对于给定的u和v，我们用倍增一边跳一边维护最小值到LCA为止，然后特判一下u=v和LCA=根的情况，重复此过程
最后答案大概是这样的
$$ans=min(dp[1][0]-dp[lca][1]+l1,dp[1][1]-min(dp[lca][1],dp[lca][0])+min(l1,l0));$$
注意这题的深度限制很严格，最好进行一些常数优化和限制，无脑lca会炸

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm> 
#include<cmath>
#include<cstring>
using namespace std;
typedef long long ll;
const int maxn = 4e5+7;
const ll INF = 1e14+7;
const int N = 25;
const int mi[20] = {1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072}; 
struct node
{
	int to,next;
}edge[maxn*2];
int cnt,head[maxn],Log[maxn];
void add(int from,int to)
{
	edge[++cnt].to=to;
	edge[cnt].next=head[from];
	head[from]=cnt;
}
ll dp[maxn][2],fa[maxn][N+2],n,m,u,v,x,y,f[maxn][N+2][2][2],val[maxn],dep[maxn];
string r_n_m;

void dfs1(int now)
{
	dp[now][1]=val[now];dep[now]=dep[fa[now][0]]+1;// 初始化值 
	f[now][0][0][0]=INF;//  不存在两个都不选的情况 
	for(int i=1;mi[i]<dep[now];i++)fa[now][i]=fa[fa[now][i-1]][i-1];// 倍增求爹 
	for(int i=head[now];i;i=edge[i].next)
	{
		int to=edge[i].to;
		if(to==fa[now][0])continue;
		fa[to][0]=now,dfs1(to);
		dp[now][1]+=min(dp[to][1],dp[to][0]);/// 正常的树形dp 
		dp[now][0]+=dp[to][1];
	}
}

void dfs2(int now)//  预处理f数组 
{
	f[now][0][1][0]=dp[fa[now][0]][0]-dp[now][1];//  因为不包括now这个点，所以减去，但是fa[now][i]的其他子树不会被删，达到 
	f[now][0][0][1]=f[now][0][1][1]=dp[fa[now][0]][1]-min(dp[now][0],dp[now][1]);// 统计一整条路径的目的 
	for(int i=1;mi[i]<dep[now];i++)
	{
		int Fa_Q=fa[now][i-1];
		f[now][i][0][0]=min(f[now][i-1][0][0]+f[Fa_Q][i-1][0][0],f[now][i-1][0][1]+f[Fa_Q][i-1][1][0]);
		f[now][i][1][1]=min(f[now][i-1][1][0]+f[Fa_Q][i-1][0][1],f[now][i-1][1][1]+f[Fa_Q][i-1][1][1]);
		f[now][i][1][0]=min(f[now][i-1][1][0]+f[Fa_Q][i-1][0][0],f[now][i-1][1][1]+f[Fa_Q][i-1][1][0]);
		f[now][i][0][1]=min(f[now][i-1][0][0]+f[Fa_Q][i-1][0][1],f[now][i-1][0][1]+f[Fa_Q][i-1][1][1]);
	}//   倍增式转移法 
	for(int i=head[now];i;i=edge[i].next)if(edge[i].to!=fa[now][0])dfs2(edge[i].to);
}

void work()
{
    if(x==0&&y==0&&(fa[u][0]==v||fa[v][0]==u))
    {
        cout<<"-1"<<endl;
        return ;
    }/// 加一个无解的特判 
	if(dep[u]<dep[v])swap(u,v),swap(x,y);// 保证u比v深 
	ll u1=INF,u0=INF,v1=INF,v0=INF,l1=INF,l0=INF,lca,ans=0;
	x?u1=dp[u][1]:u0=dp[u][0],y?v1=dp[v][1]:v0=dp[v][0];
	for(int i=Log[dep[u]-dep[v]];i>=0;i--)
	{
		ll t1=u1,t0=u0;
		if(dep[u]-mi[i]>=dep[v])//  在倍增的路上求出等深路径上的值 
		{
			u1=min(t1+f[u][i][1][1],t0+f[u][i][0][1]);
			u0=min(t1+f[u][i][1][0],t0+f[u][i][0][0]);
			u=fa[u][i];
		}
	}
	if(u==v)lca=u,y?l1=u1:l0=u0;//  特判u==v 
	else
	{
		for(int i=Log[dep[u-1]];i>=0;i--)
		{
			ll t1=u1,t0=u0,p1=v1,p0=v0;
			if(fa[u][i]!=fa[v][i])//   uv一块跳 
			{
				u1=min(t1+f[u][i][1][1],t0+f[u][i][0][1]);
				u0=min(t1+f[u][i][1][0],t0+f[u][i][0][0]);
				u=fa[u][i];
				v1=min(p1+f[v][i][1][1],p0+f[v][i][0][1]);
				v0=min(p1+f[v][i][1][0],p0+f[v][i][0][0]);
				v=fa[v][i];
			}
		}
		lca=fa[u][0];
		l0=u1+v1+dp[lca][0]-dp[u][1]-dp[v][1];
		l1=min(v0,v1)+min(u0,u1)-min(dp[u][0],dp[u][1])-min(dp[v][1],dp[v][0])+dp[lca][1];//  更新lca为根子树的权值 
	}
	if(lca==1)ans=min(l0,l1);//  特判 
	else
	{
		for(int i=Log[dep[lca]-2];i>=0;i--)
		{
			ll t1=l1,t0=l0;
		    if(dep[lca]-mi[i]>1)
            {
			    l1=min(t1+f[lca][i][1][1],t0+f[lca][i][0][1]),
		    	l0=min(t1+f[lca][i][1][0],t0+f[lca][i][0][0]),
	    		lca=fa[lca][i];//  从lca开始更新答案 
            }
		}
		ans=min(dp[1][0]-dp[lca][1]+l1,dp[1][1]-min(dp[lca][1],dp[lca][0])+min(l1,l0));//  答案统计 
	}
	if(ans==INF)cout<<"-1"<<endl;
	else cout<<ans<<endl;
}

int main()
{
	cin>>n>>m>>r_n_m;
	for(int i=1;i<=n;i++)scanf("%lld",&val[i]);
	for(int i=2;i<=n;i++)
	{
		scanf("%lld%lld",&u,&v);
		add(u,v),add(v,u);
        Log[i]=Log[i>>1]+1; 
	}
	dfs1(1),dfs2(1);
	while(m--)scanf("%lld%lld%lld%lld",&u,&x,&v,&y),work();
	return 0;
}