POJ - 3728 The merchant

若买卖不在相邻城市，朴素的想法是遍历找出路径，然后找出路径上的最高最低价格得到价格差。然而每次光找路径就要耗费O(n)的时间，而题目中肯定有多个Query。

用动态规划的思路解决问题，对指定两点uv，假设v往上走2^k步的父节点为t，走2^(k+1)步的父节点为u，如下图所示

边上的数字表示深度之差。

定义四个dp数组：

int dp_max[MAX_LOG_V][MAX_V], dp_min[MAX_LOG_V][MAX_V]; // 往上走2^k步之间的最高与最低价格
int dp_up[MAX_LOG_V][MAX_V], dp_down[MAX_LOG_V][MAX_V]; // [从v往上走2^k步之间]或[往下走2^k步到v之间]相应的最大利润
前两个很好计算，对于uv的dp_up，买卖事件有3种情况：

买和卖都发生在ut之间

买和卖都发生在tv之间

买和卖分别发生在ut和tv之间

所以递推公式如下

dp_up[k + 1][v] = max(max(dp_up[k][v], dp_up[k][t]), dp_max[k][t] - dp_min[k][v]);
同理有dp_down。

预处理算出这4个dp数组后，对任意uv，取t=lca，用类似的思想分成3种情况（对于前两种情况有down和up的子分支），取最大值即可。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;

const int MaxN = 50000;
const int MaxLog = 16;

int n, m;
vector<int> g[MaxN + 1];
int w[MaxN + 1], f[MaxLog][MaxN + 1], depth[MaxN + 1];
int dp_max[MaxLog][MaxN + 1], dp_min[MaxLog][MaxN + 1];
int dp_up[MaxLog][MaxN + 1], dp_down[MaxLog][MaxN + 1];

void dfs(int u, int fa, int deep)
{
    f[0][u] = fa;
    depth[u] = deep;
    dp_max[0][u] = max(w[u], w[fa]);
    dp_min[0][u] = min(w[u], w[fa]);
    dp_up[0][u] = max(w[fa] - w[u], 0);
    dp_down[0][u] = max(w[u] - w[fa], 0);
    for (int i = 0; i < g[u].size(); i++)
    {
        int v = g[u][i];
        if (v != fa)
            dfs(v, u, deep + 1);
    }
}

void init()
{
    memset(dp_max, 0, sizeof(dp_max));
    memset(dp_min, 0x3f, sizeof(dp_min));

    dfs(1, 0, 1);
    for (int k = 0; k + 1 < MaxLog; k++)
        for (int v = 1; v <= n; v++)
        {
            if (!f[k][v])
                f[k + 1][v] = 0;
            else
            {
                f[k + 1][v] = f[k][f[k][v]];
                int t = f[k][v];
                dp_max[k + 1][v] = max(dp_max[k][v], dp_max[k][t]);
                dp_min[k + 1][v] = min(dp_min[k][v], dp_min[k][t]);
                dp_up[k + 1][v] = max(max(dp_up[k][v], dp_up[k][t]), dp_max[k][t] - dp_min[k][v]);
                dp_down[k + 1][v] = max(max(dp_down[k][v], dp_down[k][t]), dp_max[k][v] - dp_min[k][t]);
            }
        }
}

int lca(int a, int b)
{
    if (depth[a] < depth[b])
        swap(a, b);
    int d = depth[a] - depth[b];
    for (int i = 0; d; d >>= 1, i++)
        if (d & 1)
            a = f[i][a];
    if (a == b)
        return a;
    for (int i = MaxLog - 1; i >= 0; i--)
        if (f[i][a] != f[i][b])
            a = f[i][a], b = f[i][b];
    return f[0][a];
}

int up(int x, int k, int &min_price)
{
    min_price = 0x3f3f3f3f;
    int max_profit = 0;
    int prev_min_price = 0x3f3f3f3f;
    for (int i = MaxLog - 1; i >= 0; i--)
    {
        if (k >> i & 1)
        {
            min_price = min(min_price, dp_min[i][x]);
            max_profit = max(max_profit, dp_up[i][x]);
            max_profit = max(max_profit, dp_max[i][x] - prev_min_price);
            prev_min_price = min(prev_min_price, dp_min[i][x]);
            x = f[i][x];
        }
    }
    return max_profit;
}

int down(int x, int k, int &max_price)
{
    max_price = 0;
    int max_profit = 0;
    int pre_max_price = 0;
    for (int i = MaxLog - 1; i >= 0; i--)
    {
        if (k >> i & 1)
        {
            max_price = max(max_price, dp_max[i][x]);
            max_profit = max(max_profit, dp_down[i][x]);
            max_profit = max(max_profit, pre_max_price - dp_min[i][x]);
            pre_max_price = max(pre_max_price, dp_max[i][x]);
            x = f[i][x];
        }
    }
    return max_profit;
}

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

    for (int i = 1; i <= n; i++)
        scanf("%d", &w[i]);
    for (int i = 1; i <= n; i++)
        g[i].clear();
    for (int i = 1; i < n; i++)
    {
        int u, v;
        scanf("%d %d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    init();
    int Q;
    scanf("%d", &Q);
    while (Q--)
    {
        int u, v;
        scanf("%d %d", &u, &v);
        int k = lca(u, v);
        int max_price, min_price;
        int up_profit = up(u, depth[u] - depth[k], min_price);
        int down_profit = down(v, depth[v] - depth[k], max_price);
        int ans = max(max(up_profit, down_profit), max_price - min_price);
        printf("%d\n", ans);
    }

    return 0;
}