codevs3305 水果姐逛水果街Ⅱ

本文版权归ljh2000和博客园共有，欢迎转载，但须保留此声明，并给出原文链接，谢谢合作。

本文作者：ljh2000
作者博客：http://www.cnblogs.com/ljh2000-jump/
转载请注明出处，侵权必究，保留最终解释权！

题目描述 Description

水果姐第二天心情也很不错，又来逛水果街。

突然，cgh又出现了。cgh施展了魔法，水果街变成了树结构（店与店之间只有一条唯一的路径）。

同样还是n家水果店，编号为1~n，每家店能买水果也能卖水果，并且同一家店卖与买的价格一样。

cgh给出m个问题，每个问题要求水果姐从第x家店出发到第y家店，途中只能选一家店买一个水果，然后选一家店（可以是同一家店，但不能往回走）卖出去。求最多可以赚多少钱。

水果姐向学过oi的你求助。

输入描述 Input Description

第一行n，表示有n家店

下来n个正整数，表示每家店一个苹果的价格。

下来n-1行，每行两个整数x，y，表示第x家店和第y家店有一条边。

下来一个整数m，表示下来有m个询问。

下来有m行，每行两个整数x和y，表示从第x家店出发到第y家店。

输出描述 Output Description

有m行。

每行对应一个询问，一个整数，表示面对cgh的每次询问，水果姐最多可以赚到多少钱。

样例输入 Sample Input

10
16 5 1 15 15 1 8 9 9 15
1 2
1 3
2 4
2 5
2 6
6 7
4 8
1 9
1 10
6
9 1
5 1
1 7
3 3
1 1
3 6



样例输出
Sample Output


7
11
7
0
0
15



数据范围及提示
Data Size & Hint


0<=苹果的价格<=10^8

0<n<=200000

0<m<=10000

正解：倍增
解题报告：
　　这道题可以说是一道倍增裸题呢...然而我怎么第一眼就看出是个链剖...
　　考虑我们的路径是有方向的，也就是说必须是先买后卖。常规思路就是维护往上跳的最大值、最小值和最大收益。但是难以处理往下的情况。
　　容易发现我们做向上跳的最大收益的时候，是用上面的大-下面的小，那么如果我维护一个新的数组，用下面的大-上面的小就可以得到往下跳的最大收益。同时我维护x到lca的最小值和y到lca的最大值，再用这个最大值减最小值更新一下答案即可。

1 //It is made by ljh2000
2 #include <iostream>
3 #include <cstdlib>
4 #include <cstring>
5 #include <cstdio>
6 #include <cmath>
7 #include <algorithm>
8 #include <ctime>
9 #include <vector>
10 #include <queue>
11 #include <map>
12 #include <set>
13 #include <string>
14 #include <stack>
15 using namespace std;
16 typedef long long LL;
17 const int MAXN = 200011;
18 const int inf = (1<<30);
19 int n,m,a[MAXN],deep[MAXN],ecnt,first[MAXN],to[MAXN*2],next[MAXN*2];
20 int f[MAXN][19],maxl[MAXN][19],minl[MAXN][19],g[MAXN][19],ans,p[MAXN][19];
21
22 inline int getint(){
23     int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
24     if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
25 }
26
27 inline void dfs(int x,int fa){
28     for(int i=first[x];i;i=next[i]) {
29         int v=to[i]; if(v==fa) continue;
30         f[v][0]=x; deep[v]=deep[x]+1;
31         maxl[v][0]=max(a[v],a[x]); minl[v][0]=min(a[v],a[x]);
32         g[v][0]=max(0,a[x]-a[v]);
33         p[v][0]=max(0,a[v]-a[x]);
34         dfs(v,x);
35     }
36 }
37
38 inline void lca(int x,int y){
39     int t=0; int minx=inf,maxy=0; ans=0;
40     if(deep[x]<deep[y]) {
41         while((1<<t)<=deep[y]) t++; t--;
42         for(int i=t;i>=0;i--)
43             if(deep[y]-(1<<i)>=deep[x])
44                 ans=max(ans,p[y][i]),ans=max(ans,maxy-minl[y][i]),maxy=max(maxy,maxl[y][i]),y=f[y][i];
45     }
46     else{
47         while((1<<t)<=deep[x]) t++; t--;
48         for(int i=t;i>=0;i--)
49             if(deep[x]-(1<<i)>=deep[y])
50                 ans=max(ans,g[x][i]),ans=max(ans,maxl[x][i]-minx),minx=min(minx,minl[x][i]),x=f[x][i];
51     }
52     if(x==y) return ;
53     for(int i=t;i>=0;i--) {
54         if(f[x][i]!=f[y][i]) {
55             ans=max(g[x][i],ans);
56             ans=max(p[y][i],ans);
57             ans=max(ans,maxl[x][i]-minx);
58             ans=max(ans,maxy-minl[y][i]);
59             maxy=max(maxy,maxl[y][i]);
60             minx=min(minx,minl[x][i]);
61             x=f[x][i]; y=f[y][i];
62         }
63     }
64     ans=max(g[x][0],ans);
65     ans=max(p[y][0],ans);
66     maxy=max(maxy,maxl[y][0]);
67     minx=min(minx,minl[x][0]);
68     ans=max(ans,maxy-minx);
69 }
70
71 inline void work(){
72     n=getint(); for(int i=1;i<=n;i++) a[i]=getint(); int x,y;
73     for(int i=1;i<n;i++) {
74         x=getint(); y=getint();
75         next[++ecnt]=first[x]; first[x]=ecnt; to[ecnt]=y;
76         next[++ecnt]=first[y]; first[y]=ecnt; to[ecnt]=x;
77     }
78     deep[1]=1;
79     dfs(1,0);
80     for(int j=1;j<=18;j++) {
81         for(int i=1;i<=n;i++) {
82             f[i][j]=f[f[i][j-1]][j-1];
83             if(f[i][j]==0) continue;
84             maxl[i][j]=max(maxl[i][j-1],maxl[f[i][j-1]][j-1]);
85             minl[i][j]=min(minl[i][j-1],minl[f[i][j-1]][j-1]);
86             g[i][j]=max(g[i][j-1],g[f[i][j-1]][j-1]);
87             p[i][j]=max(p[i][j-1],p[f[i][j-1]][j-1]);
88             g[i][j]=max(g[i][j],maxl[f[i][j-1]][j-1]-minl[i][j-1]);
89             p[i][j]=max(p[i][j],maxl[i][j-1]-minl[f[i][j-1]][j-1]);
90         }
91     }
92     m=getint();
93     while(m--) {
94         x=getint(); y=getint();
95         lca(x,y);
96         printf("%d\n",ans);
97     }
98 }
99
100 int main()
101 {
102     work();
103     return 0;
104 }