2018 NOIP 提高组 复赛 day2

不得不说…noip的趋势越来越像是day1基础+思路稳定分数，基本确定你能在哪个获奖区，day2难度提高，给满分dalao拼技术和给day1二等的人一个拿一等的机会，给三等的摸一个二等的机会…
总感觉这个day2数据放大就是一套省选…

T1 旅行

题目点击→洛谷 P5022 旅行

题目描述
小 Y 是一个爱好旅行的 OIer。她来到 X 国，打算将各个城市都玩一遍。

小Y了解到， X国的 $n$ 个城市之间有 mm 条双向道路。每条双向道路连接两个城市。 不存在两条连接同一对城市的道路，也不存在一条连接一个城市和它本身的道路。并且， 从任意一个城市出发，通过这些道路都可以到达任意一个其他城市。小 Y 只能通过这些 道路从一个城市前往另一个城市。

小 Y 的旅行方案是这样的：任意选定一个城市作为起点，然后从起点开始，每次可 以选择一条与当前城市相连的道路，走向一个没有去过的城市，或者沿着第一次访问该 城市时经过的道路后退到上一个城市。当小 Y 回到起点时，她可以选择结束这次旅行或 继续旅行。需要注意的是，小 Y 要求在旅行方案中，每个城市都被访问到。

为了让自己的旅行更有意义，小 Y 决定在每到达一个新的城市（包括起点）时，将 它的编号记录下来。她知道这样会形成一个长度为 $n$ 的序列。她希望这个序列的字典序 最小，你能帮帮她吗？ 对于两个长度均为 $n$ 的序列 $A$ 和 $B$，当且仅当存在一个正整数 $x$，满足以下条件时， 我们说序列 $A$ 的字典序小于 $B$。

对于任意正整数 $1\le i<x$，序列 $A$ 的第 $i$ 个元素 $A_i$ 和序列 $B$ 的第 $i$ 个元素 $B_i$ 相同。
序列 $A$ 的第 $x$ 个元素的值小于序列 $B$ 的第 $x$ 个元素的值。
输入输出格式
输入格式：
输入文件共 $m+1$ 行。第一行包含两个整数 $n,m(m\le n)$，中间用一个空格分隔。

接下来 m 行，每行包含两个整数 $u,v(1\le u,v\le n)$ ，表示编号为 $u$ 和 $v$ 的城市之 间有一条道路，两个整数之间用一个空格分隔。

输出格式：
输出文件包含一行，$n$ 个整数，表示字典序最小的序列。相邻两个整数之间用一个 空格分隔。

输入输出样例
输入样例#1：
6 5
1 3
2 3
2 5
3 4
4 6
输出样例#1：
1 3 2 5 4 6
输入样例#2：
6 6
1 3
2 3
2 5
3 4
4 5
4 6
输出样例#2：
1 3 2 4 5 6

T1 分析

先分析数据范围
1.$m=n-1$(即普通树)， 60分
普通树的话就很简单了，因为当到达当前节点$now$的时候，必须将这个点的子树全部遍历过才能返回，并且要求字典序最小，所以暴力dfs贪心就可以了，对当前节点$now$选择最小的子节点$dfs(min(son[now]))$就可以了。
2.$m=n$ (即基环树)，40分

<基环树>是指一个有 $m$ 条边的连通图，即可以看成是一棵树中多了一条边，也就是所谓的<环套树>，那么在环中删除一条边这个图就是一棵树了。

对于这部分，首先要注意一点，对于到达过的点，只能回退到这个点，不能从它的父亲节点再次到达这个节点。所以直接贪心用优先队列维护当前能到达的所有点，选择最小的到达，并把这个点能到达的点加入队列，这个做法是肯定错的。

当然虽然题目本身是存在难度的，但是如果仔细分析的话并没有那么复杂，因为 $n\le 5000$ (毕竟还是T1…不会太夸张)
手写几组数据随便画一画就可以发现，虽然这张图存在 $m$ 条边，但是实际遍历的时候，环上一定有一条边不会被经过，这个随便画一画想清楚就好了。也就是说依旧只会经过 $m-1$ 条边。
那么就比较简单了，暴力遍历一遍环上的边，选择这条边不经过，那么对于剩下的 $m-1$条边，就是第一种情况了，直接dfs即可。求个最大的答案就可以了。
当然这里还可以发现一件事，因为数据只有 $n=5000$ ，所以其实不用求边，暴力删除$5000$条边的复杂度也就是 $O(n^2)$ ,不会 $TLE$ 的。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <set>
#include <vector>
using namespace std;

vector<int>f[5010];
int n,m,del_a,del_b,len; 
int edge[5010][2];
int ans[5010];
bool vis[5010];
int tmp[5010];


void dfs(int now){
	tmp[len++] = now;
	vis[now] = true;
	int l = f[now].size();
	for (int i = 0 ; i < l  ; ++i){
		int go = f[now][i];
		if (!vis[go] && !((now == del_a && go == del_b) || (now == del_b && go == del_a)))	
			dfs(go); 
	}
		
	return;
}

void check(){
	if (len != n) return;
	for (int i = 0 ; i < n ; ++i)
		if (tmp[i] != ans[i]){
			if (tmp[i] > ans[i]) return;
			break;
		}
	for (int i = 0 ; i < n ; ++i)
		ans[i] = tmp[i];
}


int main()
{
	scanf("%d%d",&n,&m);
	for (int i = 0 ; i < m ; ++i){
		int a,b;scanf("%d%d",&a,&b);
		f[a].push_back(b);
		f[b].push_back(a);
		edge[i][0] = a;
		edge[i][1] = b;
	}
	
	memset(ans,0x3f,sizeof(ans));
	for (int i = 1 ; i <= n ; ++i)
		sort(f[i].begin(),f[i].end());
	if (n == m){
		for (int i = 0; i < m ; ++i)
		{
			len = 0;
			memset(vis,0,sizeof(vis));
			del_a = edge[i][0];
			del_b = edge[i][1];
			dfs(1);
			check();
		}
	}else{
		del_a = del_b = -1;
		dfs(1);
		check();
	}
	for (int i = 0 ; i < n ; ++i)	
		printf("%d%c",ans[i],i!=n-1?' ':'\n');
	return 0;
} 

T2 填数游戏

题目点击→洛谷 P5023 填数游戏
小 D 特别喜欢玩游戏。这一天，他在玩一款填数游戏。
这个填数游戏的棋盘是一个$n\times m$的矩形表格。玩家需要在表格的每个格子中填入一个数字（数字 $0$ 或者数字 $1$），填数时需要满足一些限制。
下面我们来具体描述这些限制。
为了方便描述，我们先给出一些定义：

• 我们用每个格子的行列坐标来表示一个格子，即（行坐标，列坐标）。（注意： 行列坐标均从 $0$ 开始编号） 合法路径
• $P$：一条路径是合法的当且仅当：

1. 这条路径从矩形表格的左上角的格子$(0,0)$出发，到矩形的右下角格子 $(n-1,m-1)$结束；
2. 在这条路径中，每次只能从当前的格子移动到右边与它相邻的格子，或者 从当前格子移动到下面与它相邻的格子。
   例如：在下面这个矩形中，只有两条路径是合法的，它们分别是$P_1$：$(0,0)$ → $(0,1)$ → $(1,1)$和$P_2$：$(0,0)$ → $(1,0)$ → $(1,1)$。
   

对于一条合法的路径 $P$，我们可以用一个字符串$w(P)$来表示，该字符串的长度为$n+m-2$，其中只包含字符“$R$”或者字符“$D$”， 第 $i$ 个字符记录了路径 $P$ 中第 $i$ 步的移动方法，“$R$”表示移动到当前格子右边与它相邻的格子，“$D$”表示移动到当前格子下面 与它相邻的格子。例如，上图中对于路径$P_1$，有$w(P_1)=$"$RD$"；而对于另一条路径$P_2$， 有$w(P_2)=$"$DR$"。

同时，将每条合法路径 $P$ 经过的每个格子上填入的数字依次连接后，会得到一个长 度为$n+m-1$的 $01$ 字符串，记为 $s(P)$。例如，如果我们在格子$(0,0)$和$(1,0)$上填入数字 $0$，在格子$(0,1)$和$(1,1)$上填入数字 $1$（见上图红色数字）。那么对于路径$P_1$，我们可以得 到$s(P_1)=$"$011$",对于路径$P_2$，有$s(P_2)=$"$001$"。

游戏要求小 $D$ 找到一种填数字 $0$、$1$ 的方法，使得对于两条路径$P_1$，$P_2$，如果$w(P_1)>w(P_2)$，那么必须$s(P_1)\le s(P_2)$。
我们说字符串 $a$ 比字符串 $b$ 小，当且仅当字符串 $a$ 的字典序小于字符串 $b$ 的字典序，字典序的定义详见第一题。但是仅仅是找一种方法无法满 足小 $D$ 的好奇心，小 $D$ 更想知道这个游戏有多少种玩法，也就是说，有多少种填数字 的方法满足游戏的要求？

小 $D$ 能力有限，希望你帮助他解决这个问题，即有多少种填 $0$、$1$ 的方法能满足题目要求。由于答案可能很大，你需要输出答案对$10^9+7$取模的结果。

输入输出格式
输入格式：
输入文件共一行，包含两个正整数 n,mn,m，由一个空格分隔，表示矩形的大小。其 中 nn 表示矩形表格的行数，mm 表示矩形表格的列数。

输出格式：
输出共一行，包含一个正整数，表示有多少种填 $0$、$1$ 的方法能满足游戏的要求。 注意：输出答案对 $10^9+7$取模的结果。

输入输出样例
输入样例#1：
2 2
输出样例#1：
12
输入样例#2：
3 3
输出样例#2：
112
输入样例#3：
5 5
输出样例#3：
7136

T2 分析

oi一大经典类型题…暴力打表找规律。
先化简一下题意：
给定一个$n\ast m$ 网格棋盘，要求用$0/1$填充每一个格子.
使得任意两条从点 $(0,0)$ 到 $(n-1,m-1)$ 的不完全相交路径，先向右（字典序大）的路径的 $01$ 路径字典序相对小.
首先确定一件事，对于任意一种填法，棋盘中填的数字一定满足$a[i][j]\ge a[i-1,j+1]$，即从左下到右上的任意对角线中的数字一定是非递增序列。
当然这种题目…一看数据那么小，而且是固定答案的，遇事不决先暴力 …只要把$8\ast 8$的表打出来基本就能过了…
当然对于dalao来说，一看$n\le 8$，第一反应应该是状压才对…不应该是暴力…

/***********************************************/
比赛时的做法可能是这样的：

当然比赛的时候写个暴力找规律没有任何问题…$O(2^{nm})$直接上呗…
这时候会发现表很难打，打到 $n=7$ 以后就非常慢了，然后$n=8$基本上短时间内只能出一个 $(8,8)$ 的答案
当然这里不管是打表还是画图，都可以发现第二件事，那就是对于 $(n,m)$ 的答案和 $(m,n)$ 是一样的，对称一下就行了。
这时候打一个以下的表…猜一下规律，会发现相邻的两项基本上都满足 $(i,j)=(i,j-1)\ast 3$ 的规律

• $n=1$时,$ANS=2^m$
• $n=2$时,$(2,2)=12,ANS=4\ast 3^{m-1}$
• $n=3$时,$(3,3)=112,ANS=112\ast 3^{m-3}$
• $n=4$时,$(4,4)=912$发现$(4,5)=(4,4)\ast 3-3\ast 2^4$,之后的答案依旧满足上述的规律，即$ANS=2688\ast 3^{m-5}$
• $n=5$时,$(5,5)=7136$发现$(5,6)=(5,5)\ast 3-3\ast 2^5$，之后的答案依旧满足上述规律，即$ANS=21312\ast 3^{m-6}$
• $n=6$时,$(6,6)=56768$发现$(6,7)=(6,6)\ast 3-3\ast 2^6$,之后的答案依旧满足上述规律,即$ANS=170112\ast 3^{m-7}$
  其实这时候就算$n=7,8$后面的答案你的代码很难跑出来…猜也猜要猜一个规律上去…
  可以发现对于不满足常规规律是从$n=4$开始的，那么从$n=4$开始找规律，
  可以发现$(5,5)=(4,4)\ast 8-5\ast 2^5,(6,6)=(5,5)\ast 8-5\ast 2^6$
  那么可以猜测一下$(7,7)=(6,6)\ast 8-5\ast 2^7=453504,(8,8)=(7,7)\ast 8-5\ast 2^8=3626752$
• $n=7$时，$(7,8)=(7,7)\ast 3-3\ast 2^7=1360128$，之后的答案即$ANS=1360128\ast 2^{m-8}$
• $n=8$时，$(8,9)=(8,8)\ast 3-3\ast 2^8=10879488$，之后的答案即$ANS=10879488\ast 2^{m-9}$
  这样的话就做完了…并且可以用自己的暴力程序，开着代码一直跑，看看能不能满足自己找的规律，来告诉自己到底能估到几分，当然这个做法就是100分的…但是比赛时起码能保证自己可以获得65分，即$n\le 3$的部分
  
  这个表大概跑了半个小时左右吧，$n=8$的情况暴力跑太慢了。
  /***********************************************/

如果想要证明规律的话，需要发现以下条件

• $(n,m)=(m,n)$；
• 棋盘中填的数字一定满足$a[i][j]\ge a[i-1,j+1]$，即从左下到右上的任意对角线中的数字一定是非递增序列；
• 如果(i-1,j)和(i,j-1)的填数相同，那么以(i,j)为左上角、以(n,m)为右下角的子矩阵内所有对角线内的填数各自相等。

那么现在就可以分类讨论了：

若$(0,1),(1,0)$ 两格相同：

• 这种情况下，只需要使得$(1,1)\to (n,m)$的所有对角线上数字相同.
• 同时第一列和第一行会受其影响，画一画图，加上推一波式子可以发现，答案形如$4^x\ast 3^y\ast 2^z$

若 $(0,1),(1,0)$ 两格不同：

• $(0,2),(1,1),(2,0)$ 相同：
  这种情况类似第一种情况
• $(0,2),(1,1),(2,0)$其中一对相同：
  设 $f[i]$ 表示到第 $i$ 条对角线上时，在前两行的第 $i-1$ 条斜线上及以前有过匹配的方案数。
  即在两行中，第二行的某一格与其斜上方的格相同,一旦出现这种情况接下来第二行的填数就会有限制.
  当第一行和第二行不存在这种情况的时候，当前的一条对角线实际上有 $5$ 种填法，而当第 $i$ 条对角线上出现这种情况的时候，则只有 $4$ 种填法.
  那么考虑一下转移就可以写出：
  $f[i]=f[i-1]\ast 4+4\ast 5$
  即
  (在 $i-2$ 条斜线上以前就匹配成功的方案 $f[i-1]$) * (当前第 $i$条对角线的 $4$ 种填法) + ( $i-1$ 条斜线第一次匹配成功的 $4$ 种填法) * (当前第 $i$ 条对角线因不受任何影响所以有 $5$ 种填法.)
  

PC画图太麻烦了，这里给出 $(3,3)$ 的图
按照同样的方法可以画出接下去的几个图
$(3,3)=4^1\ast 3^1\ast 2^2+4^1\ast 3^0\ast 2^4$
$(4,4)=5^1\ast 4^0\ast 3^0\ast 2^5+5^1\ast 4^0\ast 3^1\ast 2^4+5^0\ast 4^2\ast 3^0\ast 2^5$
$(5,5)=5^1\ast 4^1\ast 3^0\ast 2^7+5^1\ast 4^0\ast 3^1\ast 2^5+5^0\ast 4^3\ast 3^0\ast 2^6$
$(6,6)=5^1\ast 4^1\ast 3^2\ast 2^7+5^1\ast 4^0\ast 3^1\ast 2^6+5^0\ast 4^4\ast 3^0\ast 2^7$

这样就可以计算出当 $n=m$的答案了.
当 $m=n+1$ 时，前两种情况是很容易推下去的。
按照第三种情况，根据最后一条对角线是否匹配成功进行讨论.
不难推出另外一种的答案实质上是
$ANS=(f[n]\ast 3+4\ast 5)\ast 2^n$
当推过几次式子之后可以发现，也满足上面打表所说的规律，$m$ 每次 $+1$ 会让答案 $\ast 3$

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <set>
#include <vector>
using namespace std;
#define LL long long
const LL mod=1e9+7;
int n,m;
LL qpow(LL a,int n){
    LL res=1;
    while (n){
		if(n&1) res=res*a%mod;
    	a = a * a % mod;
    	n>>=1;
	}
	return res%mod;
}
int main(){
    scanf("%d%d",&n,&m);
	if(n>m)swap(n,m);
    if(n==1){
        cout<<qpow(2,m)<<endl;
    }
    if(n==2){
        cout<<4*qpow(3,m-1)%mod<<endl;
    }
    if(n==3){
        cout<<112*qpow(3,m-3)%mod<<endl;
    }
    if(n==4){
        if(m==4)puts("912");
        else cout<<2688*qpow(3,m-5)%mod<<endl;
    }
    if(n==5){
        if(m==5)puts("7136");
        else cout<<21312*qpow(3,m-6)%mod<<endl;
    }
    if(n==6){
        if(m==6)puts("56768");
        else cout<<170112*qpow(3,m-7)%mod<<endl;
    }
    if(n==7){
        if(m==7)puts("453504");
        else cout<<1360128*qpow(3,m-8)%mod<<endl;
    }
    if(n==8){
        if(m==8)puts("3626752");
        else cout<<10879488*qpow(3,m-9)%mod<<endl;
    }
}

T3 保卫王国

题目点击→洛谷 P5024 保卫王国

题目描述
Z 国有$n$座城市，$n-1$条双向道路，每条双向道路连接两座城市，且任意两座城市 都能通过若干条道路相互到达。
Z 国的国防部长小 Z 要在城市中驻扎军队。驻扎军队需要满足如下几个条件：
一座城市可以驻扎一支军队，也可以不驻扎军队。
由道路直接连接的两座城市中至少要有一座城市驻扎军队。
在城市里驻扎军队会产生花费，在编号为i的城市中驻扎军队的花费是$p_i$。
小 Z 很快就规划出了一种驻扎军队的方案，使总花费最小。但是国王又给小 Z 提出 了mm个要求，每个要求规定了其中两座城市是否驻扎军队。小 Z 需要针对每个要求逐一 给出回答。具体而言，如果国王提出的第$j$个要求能够满足上述驻扎条件（不需要考虑 第 $j$ 个要求之外的其它要求），则需要给出在此要求前提下驻扎军队的最小开销。如果 国王提出的第$j$个要求无法满足，则需要输出$-1(1\le j\le m)$。现在请你来帮助小 Z。

输入输出格式
输入格式：
第 $1$ 行包含两个正整数$n,m$和一个字符串$type$，分别表示城市数、要求数和数据类型。$type$是一个由大写字母 $A$，$B$ 或 $C$ 和一个数字 $1$，$2$，$3$ 组成的字符串。它可以帮助你获得部分分。你可能不需要用到这个参数。这个参数的含义在【数据规模与约定】中 有具体的描述。

第 $2$ 行$n$个整数$p_i$，表示编号$i$的城市中驻扎军队的花费。
接下来 $n-1$ 行，每行两个正整数$u,v$，表示有一条$u$到$v$的双向道路。
接下来 $m$ 行，第jj行四个整数$a,x,b,y(a̸=b)$，表示第jj个要求是在城市$a$驻扎$x$支军队， 在城市$b$驻扎yy支军队。其中，$x$ 、 $y$ 的取值只有 $0$ 或 $1$：若 $x$ 为 $0$，表示城市 $a$ 不得驻 扎军队，若 $x$ 为 $1$，表示城市 $a$ 必须驻扎军队；若 $y$ 为 $0$，表示城市 $b$不得驻扎军队， 若 $y$ 为 $1$，表示城市 $b$ 必须驻扎军队。

输入文件中每一行相邻的两个数据之间均用一个空格分隔。

输出格式：
输出共 $m$ 行，每行包含 $1$ 个整数，第$j$行表示在满足国王第$j$个要求时的最小开销， 如果无法满足国王的第$j$个要求，则该行输出$-1$。

输入输出样例
输入样例#1：
5 3 C3
2 4 1 3 9
1 5
5 2
5 3
3 4
1 0 3 0
2 1 3 1
1 0 5 0
输出样例#1：
12
7
-1

T3 分析

黑科技题目…反正我不会… 动态dp模板题，甚至还能实现一下传说中的“全局平衡二叉树”…
简述一下题意：对一颗$n$个点的树进行染色，对第$i$个点染色的花费是$p_i$,要求相邻的两个点之间必须有一个点被染色，然后给出$m$组询问，每次询问强制对两个点固定状态（染色或不染色）

先考虑比赛时的做法：乍一看不会做怎么办…我们暴力一发O(nm)再说…
对于每个点可以选或不选，所以我们用：
$$\{\begin{array}{l}dp[i][1]表示以i为根的子树，在i节点选择时的最小费用\\ dp[i][0]表示以i为根的子树，在i节点不选时的最小费用\end{array}$$
同时，还要求相邻的两个节点至少有一个要选，所以如果 $i$ 不选，则 $i$ 的所有叶节点必须都选，如果 $i$ 选择，则叶节点没有限制。

以此得到状态转移（ $j$ 为 $i$ 的叶节点，$a[i]$ 为 $i$ 节点的权值）：
$$\{\begin{array}{l}dp[i][1]=\sum min(dp[j,1],dp[j,0])+a[i]\\ dp[i][0]=\sum dp[j,1]\end{array}$$
对于每个询问，若必选则将权值修改为$0$，若不选则将权值修改为$INF$，最后输出$min(dp[1,1],dp[1,0])$
时间复杂度$O(nm)$，44分。

显然对于整个代码，进行dp是必须的，那么上面的代码慢在哪里呢？显然是对于每次询问都对整棵树重新做一次dp了，显然对于只修改两个点，可能对于dp值只需要修改几个关键点就可以了，很多点的值是不需要修改的，但是我们依旧做了一次dp，所以可以猜想优化应该在这里。
那么我们考虑修改两个值对整个dp数组会有多少影响。

假设修改x，y两个点，观察一下对整棵树的影响
$1$表示根节点，$F$表示$x,y$的最近公共祖先，$A$表示$F$不包含$x,y$的子树，$B$表示根节点$1$不包含$x,y$的子树，$C,D$分别表示$x,y$的子树

我们可以发现，对于x,y修改，对整棵树的影响只有$x\to 1和y\to 1$这两条路径上的值。其他点的值都是不会修改的。
所以其实我们对于每个询问需要做的就是修改$x,y$后，将$x,y$的值重新更新到根节点$1$。
因为在结果上我们需要更新的路径可以分为三段：$x\to L，y\to L，L\to 1$，即$x,y$到达$LCA(x,y)$，再从$LCA(x,y)$到达根节点$1$
所以考虑维护一个数组$f[x][0/1][y][0/1]$表示x不选/选，y不选/选时，x到y这条路径上能得到的最大的dp值.
接下去就可以对询问处理答案了，但是这里需要的空间是$(n^2)$所以我们考虑修改一下记录方式。因为这个数组维护的目的其实也是使得$x,y$到达$LCA(x,y)$,所以我们用倍增的方式来优化这个数组。
即将数组维护成$f[x][0/1][i][0/1]$表示 $x$ 不选/选，从 $x$ 往上跳 $2^i$ 步的节点不选/选时,这条路上能得到的最大dp值。
接下去考虑一件事情，因为$x\to L$这条路径中，可能还存在一些点，这些点也存在它们的子树，而这个方程是没有办法考虑到这件事情的，所以我们需要重新定义方程:
设$f[u][0/1][i][0/1]$表示 $x$ 不选/选，从 $x$ 往上跳 $2^i$ 步的节点不选/选时,这条路上能得到的最大dp值 且计入其他子树的最终dp值。即在整个祖先节点的子树中减去 $x$ 的子树的影响。
然后我们得到转移方程：
$$\{\begin{array}{l}f[u][0][i][0]=min(f[u][0][i-1][0]+f[F][0][i-1][0],f[u][0][i-1][1]+f[F][1][i-1][0]);\\ f[u][0][i][1]=min(f[u][0][i-1][0]+f[F][0][i-1][1],f[u][0][i-1][1]+f[F][1][i-1][1]);\\ f[u][1][i][0]=min(f[u][1][i-1][0]+f[F][0][i-1][0],f[u][1][i-1][1]+f[F][1][i-1][0]);\\ f[u][1][i][1]=min(f[u][1][i-1][0]+f[F][0][i-1][1],f[u][1][i-1][1]+f[F][1][i-1][1]);\end{array}$$
样我们可以直接把$x,y$到 $L$ 的路径上的 f 数组加起来，并加上 $x,y$ 的子树的贡献，再加上从 $L$ 开始到根节点$1$的贡献，再加上子树$A和B$的贡献，就是最终的答案了。

当然这里还存在一些小问题，比如我们要用新的$x$的$dp$值更新出新的$x$的父亲$father$的$dp$值时，要计算$father$别的子树的贡献，它保存在$dp[0/1][fa]$中，但是$dp[0/1][u]$即我们当前要替换的旧的$dp$值也算在里面了
设新的$x$的$dp$值为$New$，新的$father$的$dp$值即为
$$\{\begin{array}{l}l0=dp[0][L]-dp[1][u]-dp[1][v]+u1+v1;\\ l1=dp[1][L]-min(dp[0][u],dp[1][u])-min(dp[0][v],dp[1][v])+min(u0,u1)+min(v0,v1);\end{array}$$
然后两个特殊情况：

1. 当$x,y$在一条链上时，倍增$x$之后已经在$L$上了，此时直接倍增$L$即可；
2. 当$LCA(x,y)$为根节点时，显然不需要倍增$L$，此时直接算出总答案。

还有个小问题…$INF$不要用$0x3f3f3f3f3f3f3f3f$…要用$100000\ast 100000再多补个0$

#include <iostream>
#include <cstdio>
#include <cctype>
#define LL long long
#define INF 100000000000
using namespace std;
const int step[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072};

int cnt = 0,n,m;
long long p[100050];
int father[100050][20],head[100050];
int dep[100050];
int log[100050];
LL dp[100050][3];
LL f[100050][3][20][3];
struct XX{
	int to,nxt;
}edg[201000];

void dfs(int u){
    dep[u] = dep[father[u][0]] + 1;
	dp[u][1] = p[u];
	f[u][0][0][0] = INF; 
    for(int i = 1 ; step[i] < dep[u] ; ++i) 
		father[u][i] = father[father[u][i-1]][i-1];
    for(int i = head[u] ; i ; i = edg[i].nxt){
		int v = edg[i].to;
        if(v != father[u][0]) {
			father[v][0] = u;
			dfs(v);
            dp[u][0] += dp[v][1];
			dp[u][1] += min(dp[v][0],dp[v][1]);
		}
    } 
}

void ddfs(int u){
    f[u][1][0][0] = dp[father[u][0]][0] - dp[u][1];
    f[u][0][0][1] = f[u][1][0][1] = dp[father[u][0]][1] - min(dp[u][0],dp[u][1]);
    for(int i = 1 ; step[i] < dep[u] ; ++i){
        int F = father[u][i-1];
        f[u][0][i][0] = min(f[u][0][i-1][0] + f[F][0][i-1][0],f[u][0][i-1][1] + f[F][1][i-1][0]);
        f[u][0][i][1] = min(f[u][0][i-1][0] + f[F][0][i-1][1],f[u][0][i-1][1] + f[F][1][i-1][1]);
        f[u][1][i][0] = min(f[u][1][i-1][0] + f[F][0][i-1][0],f[u][1][i-1][1] + f[F][1][i-1][0]);
        f[u][1][i][1] = min(f[u][1][i-1][0] + f[F][0][i-1][1],f[u][1][i-1][1] + f[F][1][i-1][1]);
    }
    for(int i = head[u] ; i ; i = edg[i].nxt) 
		if(edg[i].to != father[u][0]) 
			ddfs(edg[i].to);
}
void work(){
	int u,x,v,y;
	scanf("%d%d%d%d",&u,&x,&v,&y);
    if(dep[u] < dep[v]){
		swap(u,v);
		swap(x,y);
	}
    
    LL L,x0,x1,y0,y1,l0,l1,ans;
    x0 = x1 = y0 = y1 = l0 = l1 = INF;
	if (x) x1 = dp[u][1];
	else x0 = dp[u][0];
	if (y) y1 = dp[v][1];
	else y0 = dp[v][0];
	for(int i = log[dep[u] - dep[v]] ; i >= 0 ; --i) 
		if(dep[u] - step[i] >= dep[v]){
	        LL t0 = x0;
			LL t1 = x1;
	        x0 = min(t0 + f[u][0][i][0],t1 + f[u][1][i][0]),
	        x1 = min(t0 + f[u][0][i][1],t1 + f[u][1][i][1]),
	        u = father[u][i];
    } //u往上跳
    if(u==v) {
		L = u;
		if (y) l1 = x1;
		else l0 = x0;
	}
	else{
        for(int i = log[dep[u]-1] ; i >= 0 ; --i) 
			if(father[u][i] != father[v][i]){
	            LL t0 = x0;
				LL t1 = x1;
				LL p0 = y0;
				LL p1 = y1;
	            x0 = min(t0 + f[u][0][i][0],t1 + f[u][1][i][0]);
	            x1 = min(t0 + f[u][0][i][1],t1 + f[u][1][i][1]);
	            y0 = min(p0 + f[v][0][i][0],p1 + f[v][1][i][0]);
	            y1 = min(p0 + f[v][0][i][1],p1 + f[v][1][i][1]);
	            u = father[u][i];
				v = father[v][i];
        } 
        L = father[u][0];
		l0 = dp[L][0] - dp[u][1] - dp[v][1] + x1 + y1;
        l1 = dp[L][1] - min(dp[u][0],dp[u][1]) - min(dp[v][0],dp[v][1]) + min(x0,x1) + min(y0,y1);
    }
    if(L == 1) ans=min(l0,l1);
    else{
        for(int i = log[dep[L]-2]; i >= 0 ; --i) 
			if(dep[L] - step[i] > 1){
	            LL t0 = l0;
				LL t1 = l1;
	            l0 = min(t0 + f[L][0][i][0],t1 + f[L][1][i][0]);
	            l1 = min(t0 + f[L][0][i][1],t1 + f[L][1][i][1]);
	            L = father[L][i];
        }
        ans=min(dp[1][0] - dp[L][1] + l1 , dp[1][1] - min(dp[L][0],dp[L][1]) + min(l0,l1));
    }
    if (ans < INF) printf("%lld\n",ans);
    else puts("-1");
}
void init(){	
	for (int i = 2 ; i <= n ; ++i) log[i] = log[i >> 1] + 1;
	dfs(1);
	ddfs(1);
}
void add(int u,int v){ 
	edg[++cnt] = XX{v,head[u]};
	head[u] = cnt; 
}

int main(){
	scanf("%d%d%*s",&n,&m);
	for (int i = 1 ; i <= n ; ++i) scanf("%lld",&p[i]);
	for (int i = 0 ; i < n - 1 ; ++i){
		int u,v;scanf("%d%d",&u,&v);
		add(u,v);
		add(v,u);
	}	
	init();
    while(m--) work();
    return 0;
}