poj3728(lca / tarjan离线)

题目链接: http://poj.org/problem?id=3728

题意: 给出一棵带点权值的树, 对于 q 组形如 x, y 的询问, 一个人要从 x 到 y(单向), 他可以在路上任意一点以此点的的权值买一件物品, 并在接下来的路程中任意一点将其以该点的权值卖出, 输出其最大收益, 若不能获益则输出 0 .

思路: 若不考虑时间复杂度的话对于询问 x, y. 可以先求出 lca(x, y), 然后再 x -> lca -> y 路径上求一下最大收益即可. 然而这样会 tle.

可以考虑一下化简后面部分.

对于一组询问 x, y. 最大收益有 3 种情况:

1. x -> lca 过程中取得最大值

2. lca -> y 过程中取得最大值

3. lca -> y 中的最大权值减去 x -> lca 中的最小权值

为了方便处理这 3 种情况, 分别取

up 数组, up[x] 为 x -> lca 过程中能取得的最大值

dow 数组, dow[x] 为 lca -> x 过程中能取得的最大值

mi 数组, mi[x] 为 x -> lca 过程中最小权值

mx 数组, mx[x] 为 x -> lca 过程中最大权值

则第三种情况为: mx[y] - mi[x]

那么 x, y 的最大收益可以表示为: max(max(up[x], dow[y]), mx[y] - mi[x])

然而如果对于每一组 x, y 都更新一遍 up, dow, mi, mx 数组的话, 显然也是会 tle 的, 但是我们并没有必要那样做.

若对于询问 x, y, 我们已经的到了对应的 up, dow, mi, mx 数组, 那么对于 lca 在 lca(x, y) 上面的询问, 即对于 lca 为 lca(x, y) 祖先节点的询问 x1, x2,

假设 lca(x, y) 在 lca(x1, y1) 左子树中, 我们可以只更新 lca(x, y) 和 y1 到 lca(x1, y1) 对应的数组即可, 而无需更新 x1, y1 到 lca(x1, y1) 对应的数组.

如此, 我们可以按照询问的 lca 值从树的底层向上更新答案, 只需遍历一次树即可.

具体操作为; 在 tarjan 递归过程中先处理出所有询问的 lca, 然后在回溯时按 lca 自底向上更新答案即可.

代码:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 using namespace std;

 const int MAXN = 5e4 + ;
 struct node{
     int v, ip, next;
     node(){};
     node(int V, int IP, int NEXT) : v(V), ip(IP), next(NEXT){};
 }edge1[MAXN << ], edge2[MAXN << ], edge3[MAXN << ];

 int pre[MAXN], a[MAXN], b[MAXN];
 int head1[MAXN], head2[MAXN], head3[MAXN], id1, id2, id3;
 int vis[MAXN], up[MAXN], dow[MAXN], mi[MAXN], mx[MAXN], sol[MAXN];

 void init(void){
     memset(vis, , sizeof(vis));
     memset(head1, -, sizeof(head1));
     memset(head2, -, sizeof(head2));
     memset(head3, -, sizeof(head3));
     id1 = id2 = id3 = ;
 }

 void addedge1(int u, int v, int ip){
     edge1[id1] = node(v, ip, head1[u]);
     head1[u] = id1++;
 }

 void addedge2(int u, int v, int ip){
     edge2[id2] = node(v, ip, head2[u]);
     head2[u] = id2++;
 }

 void addedge3(int u, int v, int ip){
     edge3[id3] = node(v, ip, head3[u]);
     head3[u] = id3++;
 }

 int find(int v){//压缩路径并处理路径上的 up, dow, mi, mx 数组
     if(v == pre[v]) return v;//到叶子节点或者下面的lca时停止递归
     int fa = pre[v];
     pre[v] = find(pre[v]);
     up[v] = max(max(up[v], up[fa]), mx[fa] - mi[v]);//以 v -> lca 为入边
     dow[v] = max(max(dow[v], dow[fa]), mx[v] - mi[fa]);//以 lca -> v 为出边
     mi[v] = min(mi[v], mi[fa]);
     mx[v] = max(mx[v], mx[fa]);
     return pre[v];
 }

 void tarjan(int u){
     vis[u] = ;
     pre[u] = u;
     for(int i = head2[u]; i != -; i = edge2[i].next){
         int v = edge2[i].v;
         int ip = edge2[i].ip;
         if(vis[v]){
             int f = find(v);
             addedge3(f, v, ip);//记录以 f 为 lca 的询问
         }
     }
     for(int i = head1[u]; i != -; i = edge1[i].next){
         int v = edge1[i].v;
         if(!vis[v]){
             tarjan(v);
             pre[v] = u;
         }
     }
     for(int i = head3[u]; i != -; i = edge3[i].next){//回溯时计算以 u 为 lca 的询问
         int ip = edge3[i].ip;
         find(a[ip]);
         find(b[ip]);
         sol[ip] = max(max(up[a[ip]], dow[b[ip]]), mx[b[ip]] - mi[a[ip]]);
     }
 }

 int main(void){
     int n, x, y, q;
     while(~scanf("%d", &n)){
         init();
         for(int i = ; i <= n; i++){
             scanf("%d", &x);
             up[i] = dow[i] = ;
             mi[i] = mx[i] = x;
         }
         for(int i = ; i < n; i++){
             scanf("%d%d", &x, &y);
             addedge1(x, y, i);
             addedge1(y, x, i);
         }
         scanf("%d", &q);
         for(int i = ; i < q; i++){
             scanf("%d%d", &x, &y);
             a[i] = x;
             b[i] = y;
             addedge2(x, y, i);
             addedge2(y, x, i);
         }
         tarjan();
         for(int i = ; i < q; i++){
             printf("%d\n", sol[i]);
         }
     }
     return ;
 }