HDU 4123 Bob’s Race（RMQ）

题意是说给出一棵树，N（10^5）个顶点，以及每条边的权值，现在需要选择连续的K个点（顶点编号连续），可以被选出来的条件是：

                         若d[i]代表顶点i到树上其他点的距离的最大值，使得区间[a, b]的d值的最大差值不大于Q，

                         也就是max(d[a], d[a + 1], ..., d[b]) - max(d[a], d[a + 1], ..., d[b]) <= Q

Q是给出的一个查询（共有m<=500个查询），求对应每一个查询的K的最大值

思路是首先预处理出每个点到其他点的最大距离, 这可以通过两遍dfs算出来，然后对于每一个查询Q，找出一个最大长度的区间，使得这个区间的最大最小值差<=Q，所以还需要RMQ预处理出每个区间的最大值与最小值（这里查询需要做到O(1)），然后扫描一遍数组便可以得到这个最大长度的区间。

#pragma comment(linker, "/STACK:1677721600")
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf (-((LL)1<<40))
#define lson k<<1, L, (L + R)>>1
#define rson k<<1|1,  ((L + R)>>1) + 1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
#define dec(i, a, b) for(int i = a; i >= b; i --)

template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }

//typedef __int64 LL;
typedef long long LL;
const int MAXN = 50000 + 100;
const int MAXM = 110000;
const double eps = 1e-8;
LL MOD = 1000000007;

struct Node {
    int v, s;
    Node(int _v = 0, int _s = 0) {
        v = _v; s = _s;
    }
};

vector<Node>G[MAXN];
int mx[MAXN], se[MAXN], d[MAXN], idx[MAXN];
int ma[MAXN][20], mi[MAXN][20];
int n, u, v, w;
int m, Q;

void init(int n) {
    rep (i, 0, n) G[i].clear();
    mem0(mx); mem0(se);
}

void dfs1(int u, int fa) {
    mx[u] = se[u] = 0;
    int sz = G[u].size();
    rep (i, 0, sz - 1) {
        int v = G[u][i].v;
        if(v == fa) continue;
        dfs1(v, u);
        int len = G[u][i].s + mx[v];
        if(len > mx[u]) se[u] = mx[u], mx[u] = len;
        else if(len > se[u]) se[u] = len;
    }
}

void dfs2(int u, int fa, int dis) {
    d[u] = max(dis, max(mx[u], se[u]));
    int sz = G[u].size();
    rep (i, 0, sz - 1) {
        int v = G[u][i].v, len = G[u][i].s;
        if(v == fa) continue;
        if(len + mx[v] == mx[u])
            dfs2(v, u, max(dis, se[u]) + len);
        else
            dfs2(v, u, max(dis, mx[u]) + len);
    }
}

void rmq_init(int n) {
    rep (i, 1, n) ma[i][0] = mi[i][0] = d[i];
    for(int j = 1; (1<<j) <= n; j ++) {
        for(int i = 1; i + (1<<j) - 1 <= n; i ++) {
            ma[i][j] = max(ma[i][j - 1], ma[i + (1 << (j - 1))][j - 1]);
            mi[i][j] = min(mi[i][j - 1], mi[i + (1 << (j - 1))][j - 1]);
        }
    }
    rep (len, 1, n) {
        idx[len] = 0;
        while((1 << (idx[len] + 1)) <= len) idx[len] ++;
    }
}

int rmq(int l, int r) {
    int k = idx[r - l + 1];
    return max(ma[l][k], ma[r - (1 << k) + 1][k]) - min(mi[l][k], mi[r - (1 << k) + 1][k]);
}

int main()
{
//    FIN;
    while(~scanf("%d %d", &n, &m) && n) {
        init(n);
        rep (i, 1, n - 1) {
            scanf("%d %d %d", &u, &v, &w);
            G[u].push_back(Node(v, w));
            G[v].push_back(Node(u, w));
        }

        //计算每个点到叶子节点的最远距离
        dfs1(1, -1);
        dfs2(1, -1, 0);

        //计算答案
        rmq_init(n);
        while(m --) {
            scanf("%d", &Q);
            int l = 1, ans = 0;
            rep (i, 1, n) {
                while(l < i && rmq(l, i) > Q) l ++;
                ans = max(ans, i - l + 1);
            }
            cout << ans << endl;
        }
    }
    return 0;
}