[POJ 3728]The merchant

Description

There are N cities in a country, and there is one and only one simple path between each pair of cities. A merchant has chosen some paths and wants to earn as much money as possible in each path. When he move along a path, he can choose one city to buy some goods and sell them in a city after it. The goods in all cities are the same but the prices are different. Now your task is to calculate the maximum possible profit on each path.

Input

The first line contains N, the number of cities.
Each of the next N lines contains w_i the goods' price in each city.
Each of the next N-1 lines contains labels of two cities, describing a road between the two cities.
The next line contains Q, the number of paths.
Each of the next Q lines contains labels of two cities, describing a path. The cities are numbered from 1 to N.

1 ≤ N, w_i, Q ≤ 50000

Output

The output contains Q lines, each contains the maximum profit of the corresponding path. If no positive profit can be earned, output 0 instead.

Sample Input

Sample Output

题解

题解：因为没有修改，所以我们可以使用树上倍增来解决，
设 $fa[i][j]$表示点 $i$ 的第 $2^j$ 个祖先
$ma[i][j]$表示点 $i$ 到点 $fa[i][j]$的最大值。
$mi[i][j]$表示点 $i$ 到点 $fa[i][j]$的最小值。
$zma[i][j]$表示点 $i$ 到点 $fa[i][j]$的最大获利。
$fma[i][j]$表示点 $fa[i][j]$到点 $i$ 的最大获利。
然后我们可以预处理出这四个数组。
即：

 ma[x][i]=max(ma[fa[x][i-]][i-],ma[x][i-]);

 mi[x][i]=min(mi[fa[x][i-]][i-],mi[x][i-]);

 zma[x][i]=max(max(zma[fa[x][i-]][i-],zma[x][i-]),ma[fa[x][i-]][i-]-mi[x][i-]);

 fma[x][i]=max(max(fma[fa[x][i-]][i-],fma[x][i-]),ma[x][i-]-mi[fa[x][i-]][i-]);

在走向最近公共祖先的路径上记录一下历史最小值,在远离最近公共祖先的路径上记录一下历史最大值(在途中和最大获利比较)。最后答案再和历史最大值-历史最小值比较一下即可。

 //It is made by Awson on 2017.10.13

 #include <set>

 #include <map>

 #include <cmath>

 #include <ctime>

 #include <stack>

 #include <queue>

 #include <string>

 #include <cstdio>

 #include <vector>

 #include <cstring>

 #include <cstdlib>

 #include <iostream>

 #include <algorithm>

 #define LL long long

 #define Min(a, b) ((a) < (b) ? (a) : (b))

 #define Max(a, b) ((a) > (b) ? (a) : (b))

 using namespace std;

 const int N = ;

 const int INF = 1e9;

 int n, m, u, v, lim;

 struct tt {

   int to, next;

 }edge[(N<<)+];

 int path[N+], top;

 int cost[N+];

 int dep[N+], fa[N+][], maxn[N+][], minn[N+][], up[N+][], down[N+][];

 void add(int u, int v) {

   edge[++top].to = v;

   edge[top].next = path[u];

   path[u] = top;

 }

 void dfs(int u, int depth) {

   dep[u] = depth;

   for (int i = path[u]; i; i = edge[i].next)

     if (dep[edge[i].to] == ) {

       maxn[edge[i].to][] = Max(cost[edge[i].to], cost[u]);

       minn[edge[i].to][] = Min(cost[edge[i].to], cost[u]);

       up[edge[i].to][] = Max(, cost[u]-cost[edge[i].to]);

       down[edge[i].to][] = Max(, cost[edge[i].to]-cost[u]);

       fa[edge[i].to][] = u;

       dfs(edge[i].to, depth+);

     }

 }

 void ST() {

   for (int t = ; t <= lim; t++)

     for (int i = ; i <= n; i++) {

       int v = fa[i][t-];

       fa[i][t] = fa[v][t-];

       maxn[i][t] = Max(maxn[i][t-], maxn[v][t-]);

       minn[i][t] = Min(minn[i][t-], minn[v][t-]);

       up[i][t] = Max(up[i][t-], up[v][t-]), up[i][t] = Max(up[i][t], maxn[v][t-]-minn[i][t-]);

       down[i][t] = Max(down[i][t-], down[v][t-]), down[i][t] = Max(down[i][t], maxn[i][t-]-minn[v][t-]);

     }

 }

 int get_lca(int u, int v) {

   if (dep[u] < dep[v]) swap(u, v);

   for (int i = lim; i >= ; i--)

     if (dep[fa[u][i]] >= dep[v])

       u = fa[u][i];

   if (u != v) {

     for (int i = lim; i >= ; i--)

       if (fa[u][i] != fa[v][i])

     u = fa[u][i], v = fa[v][i];

     u = fa[u][], v = fa[v][];

   }

   return u;

 }

 int get_ans(int u, int v) {

   int lca = get_lca(u, v);

   int ans = , large = -INF, small = INF;

   for (int i = lim; i >= ; i--)

     if (dep[fa[u][i]] >= dep[lca]) {

       ans = Max(ans, up[u][i]);

       ans = Max(ans, maxn[u][i]-small);

       small = Min(small, minn[u][i]);

       u = fa[u][i];

     }

   for (int i = lim; i >= ; i--)

     if (dep[fa[v][i]] >= dep[lca]) {

       ans = Max(ans, down[v][i]);

       ans = Max(ans, large-minn[v][i]);

       large = Max(large, maxn[v][i]);

       v = fa[v][i];

     }

   return Max(ans, large-small);

 }

 void work() {

   scanf("%d", &n); lim = log(n*.)/log(*.);

   for (int i = ; i <= n; i++) scanf("%d", &cost[i]);

   for (int i = ; i < n; i++) {

     scanf("%d%d", &u, &v);

     add(u, v), add(v, u);

   }

   dfs(, ); ST();

   scanf("%d", &m);

   while (m--) {

     scanf("%d%d", &u, &v);

     printf("%d\n", get_ans(u, v));

   }

 }

 int main() {

   work();

   return ;

 }