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

4
1 
5 
3 
2
1 3
3 2
3 4
9
1 2
1 3
1 4
2 3
2 1
2 4
3 1
3 2
3 4

Sample Output

4
2
2
0
0
0
0
2
0

以下是分析+程式碼：

LCA+DP

/*分析:先求出點u,v的最近公共祖先f,然後求u->f->v的利潤最大值maxval
對於這個maxval可能有三種情況:
1:maxval是u->f的maxval
2:maxval是f->v的maxval
3:maxval是u->f的最小w[i]減去f->v的最大w[i]
分析到這很明顯需要設定4個變數來求maxval:
up[u]表示u->f的最大maxval
down[u]表示f->u的最大maxval
maxw[u]表示u-f的最大w[i]
minw[u]表示u-f的最小w[i]
所以maxval=max(max(up[u],down[v]),maxw[v]-minw[u]);
現在問題就是如何快速的求出這四個變數,在這裡我們可以對u,v的LCA(u,v)進行分類解決
對於LCA(u,v)是f的詢問全部求出,然後再求LCA(u,v)是f的父親的詢問
這樣當我們求LCA(u,v)是f的父親的詢問的時候就可以借用已經求出的LCA(u,v)是f的詢問
 的結果,這樣就不用反覆去求u->f的那四個變數值,u->father[f]也能快速求出
 這個變化主要在尋找father[v]這個過程中進行,具體看程式碼 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <iomanip>
#define INF 99999999
typedef long long LL;
using namespace std;

const int MAX=50000+10;
int n,m,size;
int uu[MAX],vv[MAX],ww[MAX],sum[MAX];
int up[MAX],down[MAX],maxw[MAX],minw[MAX],father[MAX];
int head[MAX],head2[MAX],head3[MAX];
bool mark[MAX];

struct Edge{
	int v,id,next;
	Edge(){}
	Edge(int V,int ID,int NEXT):v(V),id(ID),next(NEXT){}
}edge[MAX*2],edge2[MAX*2],edge3[MAX*2];

void Init(int num){
	for(int i=0;i<=num;++i)head[i]=head2[i]=head3[i]=-1,mark[i]=false;
	size=0; 
}

void InsertEdge(int u,int v,int id){
	edge[size]=Edge(v,id,head[u]);
	head[u]=size++;
}

void InsertEdge2(int u,int v,int id){
	edge2[size]=Edge(v,id,head2[u]);
	head2[u]=size++;
}

void InsertEdge3(int u,int v,int id){
	edge3[size]=Edge(v,id,head3[u]);
	head3[u]=size++;
}

int findset(int v){
	if(v == father[v])return father[v];
	int fa=father[v];
	father[v]=findset(father[v]);
	up[v]=max(max(up[v],up[fa]),maxw[fa]-minw[v]);
	down[v]=max(max(down[v],down[fa]),maxw[v]-minw[fa]);
	maxw[v]=max(maxw[v],maxw[fa]);
	minw[v]=min(minw[v],minw[fa]);
	return father[v];
}

void LCA(int u){
	mark[u]=true;
	father[u]=u;
	for(int i=head2[u];i != -1;i=edge2[i].next){//對LCA(u,v)進行分類 
		int v=edge2[i].v,id=edge2[i].id;
		if(!mark[v])continue;
		int f=findset(v);
		InsertEdge3(f,v,id);
	}
	for(int i=head[u];i != -1;i=edge[i].next){
		int v=edge[i].v;
		if(mark[v])continue;
		LCA(v);
		father[v]=u;
	}
	for(int i=head3[u];i != -1;i=edge3[i].next){
		int id=edge3[i].id;
		findset(uu[id]);
		findset(vv[id]);
		sum[id]=max(max(up[uu[id]],down[vv[id]]),maxw[vv[id]]-minw[uu[id]]);
	}
}

int main(){
	int u,v;
	while(~scanf("%d",&n)){
		Init(n);
		for(int i=1;i<=n;++i){
			scanf("%d",ww+i);
			up[i]=down[i]=0;
			maxw[i]=minw[i]=ww[i];
		}
		for(int i=1;i<n;++i){
			scanf("%d%d",&u,&v);
			InsertEdge(u,v,i);
			InsertEdge(v,u,i); 
		}
		size=0;
		scanf("%d",&m);
		for(int i=0;i<m;++i){
			scanf("%d%d",&uu[i],&vv[i]);
			InsertEdge2(uu[i],vv[i],i);
			InsertEdge2(vv[i],uu[i],i); 
		}
		size=0;
		LCA(1);
		for(int i=0;i<m;++i)printf("%d\n",sum[i]);
	}
	return 0;
}

RMQ+LCA:

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <iomanip>
#define INF 99999999
typedef long long LL;
using namespace std;

const int MAX=50000+10;
int n,m,size,top;
int uu[MAX],vv[MAX],ww[MAX],anc[MAX];
int up[MAX][20],down[MAX][20],maxw[MAX][20],minw[MAX][20],deep[MAX];
int head[MAX],head2[MAX],bin[MAX],stack[MAX],mp[MAX][20],father[MAX];
bool mark[MAX];

struct Edge{
	int v,id,next;
	Edge(){}
	Edge(int V,int ID,int NEXT):v(V),id(ID),next(NEXT){}
}edge[MAX*2],edge2[MAX*2];

void Init(int num){
	for(int i=0;i<=num;++i)head[i]=head2[i]=-1,mark[i]=false;
	size=top=0;
}

void InsertEdge(int u,int v,int id){
	edge[size]=Edge(v,id,head[u]);
	head[u]=size++;
} 

void InsertEdge2(int u,int v,int id){
	edge2[size]=Edge(v,id,head2[u]);
	head2[u]=size++;
}

void dfs(int u,int father,int k){
	deep[u]=k;
	for(int i=head[u];i != -1;i=edge[i].next){
		int v=edge[i].v;
		if(v == father)continue;
		dfs(v,u,k+1);
	}
}

void RMQ(int u,int father){
	stack[++top]=u;
	int fa=stack[top-1];
	up[u][0]=down[u][0]=0;
	maxw[u][0]=minw[u][0]=ww[u];
	for(int i=1;bin[i]<=top;++i){//2^i<=top
		fa=stack[top-bin[i-1]];
		up[u][i]=max(max(up[u][i-1],up[fa][i-1]),maxw[fa][i-1]-minw[u][i-1]);
		down[u][i]=max(max(down[u][i-1],down[fa][i-1]),maxw[u][i-1]-minw[fa][i-1]);
		maxw[u][i]=max(maxw[u][i-1],maxw[fa][i-1]);
		minw[u][i]=min(minw[u][i-1],minw[fa][i-1]);
		mp[u][i]=stack[top-bin[i]];
	}
	for(int i=head[u];i != -1;i=edge[i].next){
		int v=edge[i].v;
		if(v == father)continue;
		RMQ(v,u);
	}
	--top;
}

int findset(int v){
	if(v != father[v])father[v]=findset(father[v]);
	return father[v];
}

void LCA(int u){
	mark[u]=true;
	father[u]=u;
	for(int i=head2[u];i != -1;i=edge2[i].next){
		int v=edge2[i].v,id=edge2[i].id;
		if(!mark[v])continue;
		anc[id]=findset(v);
	}
	for(int i=head[u];i != -1;i=edge[i].next){
		int v=edge[i].v;
		if(mark[v])continue;
		LCA(v);
		father[v]=u;
	}
}

int search(int x){
	int i=0;
	while(bin[i+1]<=x)++i;
	return i;
}

int Minw(int u,int anc){
	int i=search(deep[u]-deep[anc]+1);
	if(bin[i] == deep[u]-deep[anc]+1)return minw[u][i];
	return min(minw[u][i],Minw(mp[u][i],anc));
}

int Maxw(int u,int anc){
	int i=search(deep[u]-deep[anc]+1);
	if(bin[i] == deep[u]-deep[anc]+1)return maxw[u][i];
	return max(maxw[u][i],Maxw(mp[u][i],anc));
}

int Down(int u,int anc){
	int i=search(deep[u]-deep[anc]+1);
	if(bin[i] == deep[u]-deep[anc]+1)return down[u][i];
	int downfa=Down(mp[u][i],anc);
	downfa=max(downfa,down[u][i]);
	int minwfa=Minw(mp[u][i],anc);
	return max(downfa,maxw[u][i]-minwfa); 
}

int UP(int u,int anc){
	int i=search(deep[u]-deep[anc]+1);
	if(bin[i] == deep[u]-deep[anc]+1)return up[u][i];
	int upfa=UP(mp[u][i],anc);
	upfa=max(upfa,up[u][i]);
	int maxwfa=Maxw(mp[u][i],anc);
	return max(upfa,maxwfa-minw[u][i]);
}

int main(){
	bin[0]=1;
	for(int i=1;bin[i-1]<MAX;++i)bin[i]=bin[i-1]*2;
	int u,v;
	while(~scanf("%d",&n)){
		Init(n);
		for(int i=1;i<=n;++i)scanf("%d",ww+i);
		for(int i=1;i<n;++i){
			scanf("%d%d",&u,&v);
			InsertEdge(u,v,i);
			InsertEdge(v,u,i);
		}
		size=0;
		scanf("%d",&m);
		for(int i=0;i<m;++i){
			scanf("%d%d",uu+i,vv+i);
			InsertEdge2(uu[i],vv[i],i);
			InsertEdge2(vv[i],uu[i],i);
		}
		dfs(1,-1,1);
		RMQ(1,-1);
		LCA(1);	
		for(int i=0;i<m;++i){
			int upmax=UP(uu[i],anc[i]),downmax=Down(vv[i],anc[i]);	
			int Minww=Minw(uu[i],anc[i]),Maxww=Maxw(vv[i],anc[i]);
			printf("%d\n",max(max(upmax,downmax),Maxww-Minww));
		}
	}
	return 0;
}
/*
7
300
11
11
21
10
31
222
1 2
2 3
3 4
4 5
2 6
1 7
1
5 6
*/