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 }

 

转载于:https://www.cnblogs.com/ljh2000-jump/p/6072498.html