poj 3162 Walking Race 树形dp + 单调队列

题目链接

题意：

给定一棵树，编号为 1 ~ n, 

先要求得树上每一点与跟它距离最远的点之间的距离，记为数组 a,

再求得 a 中最长的区间，使得该区间中的元素最大值与最小值的差值不大于给定值 m

其实纯粹是两道题拼起来，

两部分各自的典型例题分别见：

1. hdu 2196 题目链接 blog链接

题意：给定树，求树上每一点与跟它距离最远的点之间的距离

2. hdu 3530 题目链接 blog链接 

题意：给定数组，求得最长的区间，使得其中最大值与最小值的差值在给定的范围内（>=m, <=k）

这道题看似复杂，但拆开来，做了上述两道题再写这道题就相对容易了，具体的思路与做法也请参见上面两篇blog

AC代码如下：

#include <cstdio>
#include <iostream>
#include <cstring>
#define maxn 1000010
using namespace std;
typedef long long LL;
struct Edge {
    int from, to, dist, ne;
    Edge(int a = 0, int b = 0, int c = 0, int d = 0) : from(a), to(b), dist(c), ne(d) {}
}edge[maxn * 2];
int next[maxn], tot, adj[maxn], cnt, lo[maxn], hi[maxn];
LL f[maxn][3], g[maxn];
inline LL max(LL a, LL b) { return a > b ? a : b; }
void add(int u, int v, int d) {
    Edge e(u, v, d, next[u]);
    edge[tot] = e;
    next[u] = tot++;
}
void dfs(int u, int fa) {
    f[u][0] = f[u][1] = 0;
    for (int i = next[u]; i != -1; i = edge[i].ne) {
        Edge e = edge[i]; int v = e.to;
        if (v == fa) continue;
        dfs(v, u);
        if (f[v][0] + (LL)e.dist > f[u][0]) {
            f[u][1] = f[u][0]; f[u][0] = f[v][0] + (LL)e.dist;
            adj[u] = v;
        }
        else if (f[v][0] + (LL)e.dist > f[u][1]) f[u][1] = f[v][0] + (LL)e.dist;
    }
}
void dfs2(int u, int fa) {
    for (int i = next[u]; i != -1; i = edge[i].ne) {
        Edge e = edge[i]; int v = e.to;
        if (v == fa) continue;
        if (adj[u] == v) f[v][2] = f[u][2] > f[u][1] ? f[u][2] : f[u][1];
        else f[v][2] = f[u][2] > f[u][0] ? f[u][2] : f[u][0];
        f[v][2] += (LL)e.dist;
        dfs2(v, u);
    }
}
int main() {
    memset(next, -1, sizeof(next));
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 2; i <= n; ++i) {
        int y, d;
        scanf("%d%d", &y, &d);
        add(i, y, d);
        add(y, i, d);
    }
    dfs(1, -1);
    dfs2(1, -1);
//    for (int i = 1; i <= n; ++i) printf("%d ", f[i][0]); printf("\n");
//    for (int i = 1; i <= n; ++i) printf("%d ", f[i][2]); printf("\n");

    for (int i = 1; i <= n; ++i) g[i] = max(f[i][0], f[i][2]);

    int f1 = 0, r1 = 0, f2 = 0, r2 = 0, l = 1, ans = 1;
    for (int i = 1; i <= n; ++i) {
        while (r1 > f1 && g[i] < g[lo[r1 - 1]]) --r1;
        lo[r1++] = i;
        while (r2 > f2 && g[i] > g[hi[r2 - 1]]) --r2;
        hi[r2++] = i;
        while (g[hi[f2]] - g[lo[f1]] > m) {
            l = min(hi[f2], lo[f1]) + 1;
            while (hi[f2] < l) ++f2;
            while (lo[f1] < l) ++f1;
        }
        if (g[hi[f2]] - g[lo[f1]] <= m) ans = max(ans, i - l + 1);
    }
    printf("%d\n", ans);
//    for (int i = 1; i <= n; ++i) printf("%d ", g[i]); printf("\n");
    return 0;
}