HDU 4123 Bob’s Race 树dp RMQ 尺取

题意: 每个点有编号, 点组成一棵树, 每个点求出树上的最远距离, 给出若干次询问, 问一个连续编号的区间, 满足最大值和最小值的差距<Q时, 区间的最大长度是多少.

思路: 树dp 与HDU 2196 Computer 相同的方法求出每个点的最长距离, 然后就与树无关了. 对于每一次询问, 尺取+RMQ得到满足条件的最长距离.

代码:

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

using namespace std;
const int M = 50005;
const int inf = 1e9 + 5;

namespace RMQ {
    const int MX = 50005;
    int MIN[MX][30], MAX[MX][30];
    int lg[MX];
    int A[MX];

    void RMQ_init1() {//预处理使RMQ的复杂度变为O(1)
        for (int i = 1, j = 0; i < M; ++i) {
            if (i <= (1 << (j + 1)))
                lg[i] = j;
            else
                lg[i] = ++j;
        }
    }


    void RMQ_init2(int n) {
        for (int i = 0; i < n + 1; ++i) {
            MAX[i][0] = MIN[i][0] = A[i];
        }
        for (int j = 1; (1 << j) <= n + 1; ++j) {
            for (int i = 0; i + (1 << j) - 1 < n + 1; ++i) {
                MAX[i][j] = max(MAX[i][j - 1], MAX[i + (1 << (j - 1))][j - 1]);
                MIN[i][j] = min(MIN[i][j - 1], MIN[i + (1 << (j - 1))][j - 1]);
            }
        }
    }

    int RMQ_min(int L, int R) {
        int k = lg[R - L + 1];
        return min(MIN[L][k], MIN[R - (1 << k) + 1][k]);
    }

    int RMQ_max(int L, int R) {
        int k = lg[R - L + 1];
        return max(MAX[L][k], MAX[R - (1 << k) + 1][k]);
    }
}

int m;
int n;
struct node {
    int v, nxt;
    int d;
} edge[M * 2];
int head[M];
int ei;
int dp[M][3];
int dis[M];
int vis[M];
int q;

void addedge(int u, int v, int d) {
    node x = {v, head[u], d};
    edge[ei] = x;
    head[u] = ei++;
}

int dfs(int x, int ffa) {
    int t1 = 0, t2 = 0;
    int r1 = 0, r2 = 0;
    for (int i = head[x]; i != -1; i = edge[i].nxt) {
        int v = edge[i].v;
        if (ffa == v)continue;
        dis[v] = edge[i].d;
        int t3 = dfs(v, x) + dis[v];
        if (t3 > t1) {
            t2 = t1;
            t1 = t3;
            vis[x] = v;
        } else if (t3 > t2) {
            t2 = t3;
        }
    }
    dp[x][0] = t1;
    dp[x][1] = t2;
    return dp[x][0];
}

void dfs2(int x, int f) {
    for (int i = head[x]; i != -1; i = edge[i].nxt) {
        int v = edge[i].v;
        if (f == v)continue;
        if (vis[x] == v) {
            dp[v][2] = max(dp[x][1] + dis[v], dp[x][2] + dis[v]);
        } else {
            dp[v][2] = max(dp[x][0] + dis[v], dp[x][2] + dis[v]);
        }
        dfs2(v, x);
    }
}

void init() {
    for (int i = 0; i <= n; ++i)head[i] = -1;
    ei = 0;
}

void input() {
    for (int i = 1; i < n; ++i) {
        int u, v;
        int d;
        scanf("%d%d%d", &u, &v, &d);
        addedge(u, v, d);
        addedge(v, u, d);
    }
}

void solve() {
    dfs(1, -1);
    for (int i = 1; i <= n; ++i) {
        if (dp[i][0] == 0)dp[i][0] = -inf;
        if (dp[i][1] == 0)dp[i][1] = -inf;
    }
    dfs2(1, -1);
    for (int i = 1; i <= n; ++i) {
        RMQ::A[i] = max(dp[i][0], dp[i][2]);
    }
}

void solve2() {
    RMQ::RMQ_init2(n);
    for (int i = 0; i < m; ++i) {
        int ans = 1;
        scanf("%d", &q);
        int l = 1, r = 1;
        while (l <= n && r <= n) {
            while (r <= n && (RMQ::RMQ_max(l, r) - RMQ::RMQ_min(l, r)) <= q) {
                r++;
            }
            ans = max(ans, r - l);
            l++;
        }
        printf("%d", ans);
        putchar('\n');
    }
}

int main() {
    RMQ::RMQ_init1();
    while (~scanf("%d%d", &n, &m) && n + m) {
        init();
        input();
        solve();
        solve2();
    }
    return 0;
}