POJ 3728 The merchant（LCA+DP）

The merchant

Time Limit : 6000/3000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)

Total Submission(s) : 1   Accepted Submission(s) : 1

Problem 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

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

 

Output

<div><p>The output contains
<i>Q</i> lines, each contains the maximum profit of the
corresponding path. If no positive profit can be earned, output 0 instead.
</p>

 

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

 

Source

PKU

 

题目大意

　　有一棵树，每个结点有一个物品的价值。有一些询问，问在从一个点到另一个点了路径上，先在一个地方买，再在一个地方卖的最大获利。

解题思路

　　令从uu到vv的LCA为xx，那么答案一定是从uu到xx的最大获利，从xx到vv的最大获利，xx到vv的最大值减去uu到xx的最小值。于是我们就可以在求LCA的过程中DP一下得到上面所需的东西。 
　　用离线Tarjan实现时在并查集路径压缩时进行DP，用倍增实现时直接在倍增数组上进行DP。

离线Tarjan写法

用的方法是离线LCA，在上面加了一些东西

对于一个询问， 假设u,v的LCA是f

那么有三种可能， 一个是从u到f 买卖了。 一个是从f到v买卖了，  一个是从u到f之间买了,从v到f卖了

从u到f 我们称为up，  从f到v我们称为down，而从u到f买然后在f到v卖就是求u到f的最小值和f到v的最大值。

我们要分别求这三个值

实际上就是在离线tarjan求LCA的过程中求出的

对于每个点， 我们进行dfs的时候，查看于其相关的询问，

假设当前点是u， 询问的点是v， u和v的LCA是f,如果v已经dfs过了，说明v在并查集中的祖先就是u,v的LCA  f点，

将该询问加入到f的相关集合中，等f所有的子节点都处理过后再去处理f， 就可以发现，一切都是顺其自然了

在这些处理过程中，up和down以及u,v到f的最大值最小值  都可以在并查集求压缩路径的过程中更新。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <cmath>
#include <algorithm>
#include <map>
#include <ctime>
#define MAXN 52222
#define MAXM 222222
#define INF 1000000001
using namespace std;
vector<int>g[MAXN], st[MAXN], ed[MAXN], id[MAXN], ask[MAXN], pos[MAXN];
int mx[MAXN], mi[MAXN], up[MAXN], down[MAXN], vis[MAXN], fa[MAXN], ans[MAXN];
int n, Q;
int find(int x) {
    if(x == fa[x]) return x;
    int y = fa[x];
    fa[x] = find(y);
    up[x] = max(up[x], max(mx[y] - mi[x], up[y]));
    down[x] = max(down[x], max(mx[x] - mi[y], down[y]));
    mx[x] = max(mx[x], mx[y]);
    mi[x] = min(mi[x], mi[y]);
    return fa[x];
}
void tarjan(int u) {
    vis[u] = ;
    for(int i = ; i < ask[u].size(); i++) {
        int v = ask[u][i];
        if(vis[v]) {
            int t = find(v);
            int z = pos[u][i];
            if(z > ) {
                st[t].push_back(u);
                ed[t].push_back(v);
                id[t].push_back(z);
            } else {
                st[t].push_back(v);
                ed[t].push_back(u);
                id[t].push_back(-z);
            }
        }
    }
    for(int i = ; i < g[u].size(); i++) {
        int v = g[u][i];
        if(!vis[v]) {
            tarjan(v);
            fa[v] = u;
        }
    }
    for(int i = ; i < st[u].size(); i++) {
        int a = st[u][i];
        int b = ed[u][i];
        int t = id[u][i];
        find(a);
        find(b);
        ans[t] = max(up[a], max(down[b], mx[b] - mi[a]));
    }
}  

int main() {
        scanf("%d", &n);
        int u, v, w;  

        for(int i = ; i <= n; i++) {
            scanf("%d", &w);
            mx[i] = mi[i] = w; fa[i] = i;
        }
        for(int i = ; i < n; i++) {
            scanf("%d%d", &u, &v);
            g[u].push_back(v);
            g[v].push_back(u);  

        }
        scanf("%d", &Q);
        for(int i = ; i <= Q; i++) {
            scanf("%d%d", &u, &v);
            ask[u].push_back(v);
            pos[u].push_back(i);
            ask[v].push_back(u);
            pos[v].push_back(-i);
        }
        tarjan();
        for(int i = ; i <= Q; i++) printf("%d\n", ans[i]);  

    return ;
}  

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <cmath>
#include <cstdlib>
using namespace std;
#define INF 0x3f3f3f3f
#define fi first
#define se second

const int MAXN=+;
int V, Q, val[MAXN];
vector<int> G[MAXN];
vector<pair<int, int> > q[MAXN];// id, other
vector<pair<int, int> > ans[MAXN];// to, it
int up[MAXN], down[MAXN];//当前点到lca的最大获利，lca到当前点点最大获利
int max_val[MAXN], min_val[MAXN];//当前点到lca的最大／最小价格
int par[MAXN];
bool vis[MAXN];
int res[MAXN];

int findfather(int x)//并查集查询，同时进行dp
{
    if(par[x]==x)
        return x;
    int fa=par[x];
    par[x]=findfather(par[x]);
    up[x]=max(up[x], max(up[fa], max_val[fa]-min_val[x]));
    down[x]=max(down[x], max(down[fa], max_val[x]-min_val[fa]));
    max_val[x]=max(max_val[x], max_val[fa]);
    min_val[x]=min(min_val[x], min_val[fa]);
    return par[x];
}

void tarjan(int u)
{
    par[u]=u;
    vis[u]=true;
    for(int i=;i<q[u].size();++i)//把查询保存到lca处
    {
        int v=q[u][i].se;
        if(vis[v])
        {
            int lca=findfather(v);
            ans[lca].push_back(make_pair(u, i));
        }
    }
    for(int i=;i<G[u].size();++i)
    {
        int v=G[u][i];
        if(!vis[v])
        {
            tarjan(v);
            par[v]=u;
        }
    }
    for(int i=;i<ans[u].size();++i)//处理以当前结点为lca的所有查询
    {
        int x=ans[u][i].fi, y=q[x][ans[u][i].se].se;
        int id=q[x][ans[u][i].se].fi;
        if(id<)
        {
            id=-id;
            swap(x, y);
        }
        findfather(x);
        findfather(y);
        res[id]=max(up[x], down[y]);
        res[id]=max(res[id], max_val[y]-min_val[x]);
    }
}

int main()
{
    scanf("%d", &V);
    for(int i=;i<=V;++i)
    {
        scanf("%d", &val[i]);
        max_val[i]=min_val[i]=val[i];
    }
    for(int i=;i<V;++i)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    scanf("%d", &Q);
    for(int i=;i<=Q;++i)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        q[u].push_back(make_pair(i, v));
        q[v].push_back(make_pair(-i, u));
    }
    tarjan();
    for(int i=;i<=Q;++i)
        printf("%d\n", res[i]);

    return ;
}

倍增写法

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <ctime>
#include <bitset>
using namespace std;
#define INF 0x3f3f3f3f
#define ULL unsigned long long
#define LL long long
#define fi first
#define se second
#define mem(a, b) memset((a),(b),sizeof(a))
#define sqr(x) ((x)*(x))

const int MAXN=+;
const int MAXLOG=;

int N, Q, price[MAXN];
vector<int> G[MAXN];
int dp_max[MAXLOG][MAXN], dp_min[MAXLOG][MAXN];//向上走2^k步之间的最高与最低价格
int dp_up[MAXLOG][MAXN], dp_down[MAXLOG][MAXN];//从u向上走2^k／向下走2^k步到u 的最大利润
int parent[MAXLOG][MAXN];//向上走2^k步到达的点（超过根时记为-1）
int depth[MAXN];

void dfs(int u, int fa, int deep)
{
    parent[][u]=fa;
    depth[u]=deep;
    dp_up[][u]=max(price[fa]-price[u], );
    dp_down[][u]=max(price[u]-price[fa], );
    dp_max[][u]=max(price[u], price[fa]);
    dp_min[][u]=min(price[u], price[fa]);
    for(int i=;i<G[u].size();++i)
        if(G[u][i]!=fa)
            dfs(G[u][i], u, deep+);
}

void pre_work()
{
    mem(dp_max, );
    mem(dp_min, 0x3f);
    dfs(, -, );
    for(int k=;k+<MAXLOG;++k)
    {
        for(int u=;u<N;++u)
        {
            if(parent[k][u]<)
                parent[k+][u]=-;
            else
            {
                parent[k+][u]=parent[k][parent[k][u]];
                int mid=parent[k][u];
                dp_max[k+][u]=max(dp_max[k][u], dp_max[k][mid]);
                dp_min[k+][u]=min(dp_min[k][u], dp_min[k][mid]);
                dp_up[k+][u]=max(max(dp_up[k][u], dp_up[k][mid]), dp_max[k][mid]-dp_min[k][u]);
                dp_down[k+][u]=max(max(dp_down[k][u], dp_down[k][mid]), dp_max[k][u]-dp_min[k][mid]);
            }
        }
    }
}

int lca(int u, int v)
{
    if(depth[u]>depth[v])
        swap(u, v);
    for(int k=;k<MAXLOG;++k)
        if((depth[v]-depth[u])>>k&)
            v=parent[k][v];
    if(u==v)
        return u;
    for(int k=MAXLOG-;k>=;--k)
        if(parent[k][u]!=parent[k][v])
        {
            u=parent[k][u];
            v=parent[k][v];
        }
    return parent[][u];
}

int up(int u, int k, int &the_min)
{
    the_min=INF;
    int res=, pre_min_price=INF;
    for(int i=MAXLOG-;i>=;--i)
        if(k>>i&)
        {
            the_min=min(the_min, dp_min[i][u]);
            res=max(res, dp_up[i][u]);
            res=max(res, dp_max[i][u]-pre_min_price);
            pre_min_price=min(pre_min_price, dp_min[i][u]);
            u=parent[i][u];
        }
    return res;
}

int down(int u, int k, int &the_max)
{
    the_max=;
    int res=, pre_max_price=;
    for(int i=MAXLOG-;i>=;--i)
        if(k>>i&)
        {
            the_max=max(the_max, dp_max[i][u]);
            res=max(res, dp_down[i][u]);
            res=max(res, pre_max_price-dp_min[i][u]);
            pre_max_price=max(pre_max_price, dp_max[i][u]);
            u=parent[i][u];
        }
    return res;
}

int main()
{
    scanf("%d", &N);
    for(int i=;i<N;++i)
        scanf("%d", &price[i]);
    for(int i=;i<N;++i)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        --u;
        --v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    pre_work();
    scanf("%d", &Q);
    while(Q--)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        --u;
        --v;
        int com=lca(u, v);//最近公共祖先
        int the_max, the_min;
        int up_profit=up(u, depth[u]-depth[com], the_min);
        int down_profit=down(v, depth[v]-depth[com], the_max);
        printf("%d\n", max(max(up_profit, down_profit), the_max-the_min));
    }

    return ;
}