【2018 12月集训 Day2】小奇的危机

给定一棵树，有若干次询问，每次给定 $l,r,x$，求一个点 $y$，满足 $l \le y \le r$，且最小化 $\text{dis}(x,y)$

$n,q \le 10^5, l \le r$，任意两个点的距离不超过 $10^9$

有一个十分自然的鬼畜想法就是把每个询问 $[l,r]$，拆分成 $\log n$ 个区间放到线段树上，然后依次访问线段树的每一个区间

之后对当前区间（假设是 $[L,R]$）的所有询问点和下标在 $[L,R]$ 的点建立虚树

之后就相当于给定一棵树，有一些关键点，问所有点到所有关键点的距离最小值是多少

这个可以跑两次树上动态规划来解决掉

之后就能过了……时间复杂度 $O((n+q) \log^2 n)$

如果要求强制在线呢？其实也很简单（不知道对不对……口胡一下……）……

这回就相当于给定一棵树，树上有关键点，还有若干次询问，每次给定一个点，问这个点到树上所有关键点的最近距离

这样只需要找到这个点和树的两个交点就行了，显然要么这个点在虚树外，要么在虚树上，要么在虚树上某两个点之间

对于第一种情况，只可能是该点的子树中有虚树的根，或者该点到原树的根节点的路径上有虚树的根，要么就是该点和虚树的根节点的最近公共祖先在该点到原树的根上

对于第二种情况，直接输出预处理的答案就行了

对于第三种情况，直接查找虚树上的这两个点后更新答案就行了

#include <bits/stdc++.h>
using namespace std;

struct FastIO {
    static const int S = 2e7;
    int wpos;
    char wbuf[S];
    FastIO() : wpos(0) {}
    inline int xchar() {
        static char buf[S];
        static int len = 0, pos = 0;
        if (pos == len)
            pos = 0, len = fread(buf, 1, S, stdin);
        if (pos == len) exit(0);
        return buf[pos++];
    }
    inline int operator () () {
        int c = xchar(), x = 0;
        while (c <= 32) c = xchar();
        for (; '0' <= c && c <= '9'; c = xchar()) x = x * 10 + c - '0';
        return x;
    }
    inline void wchar(int x) {
        if (wpos == S) fwrite(wbuf, 1, S, stdout), wpos = 0;
        wbuf[wpos++] = x;
    }
    inline void operator () (int x) {
        char s[24];
        int n = 0;
        while (x || !n) s[n++] = '0' + x % 10, x /= 10;
        while (n--) wchar(s[n]);
        wchar('\n');
    }
    ~FastIO()
    {
        if (wpos) fwrite(wbuf, 1, wpos, stdout), wpos = 0;
    }
} io;

const int N = 100000 + 10;

int n, q; 

int _head[N], _rest[N * 2], _to[N * 2], _w[N * 2];
void lk(int u, int v, int w) {
    static int tot = 0;
    _to[++ tot] = v, _w[tot] = w, _rest[tot] = _head[u], _head[u] = tot;
    _to[++ tot] = u, _w[tot] = w, _rest[tot] = _head[v], _head[v] = tot;
}

struct T {
    int id, x;
};

vector<T> que[N * 10];

#define lc (id << 1)
#define rc (id << 1 | 1)
void poi(int id, int l, int r, int ql, int qr, T t) {
    int mid = (l + r) >> 1;
    if(ql <= l && r <= qr) {
        que[id].push_back(t);
    } else if(qr <= mid) {
        poi(lc, l, mid, ql, qr, t);
    } else if(ql >= mid + 1) {
        poi(rc, mid + 1, r, ql, qr, t);
    } else {
        poi(lc, l, mid, ql, mid, t);
        poi(rc, mid + 1, r, mid + 1, qr, t);
    }
}

int ans[N], beg_dfn[N], end_dfn[N], clk, dep[N], len[N];
int fa[N][21];

int getlca(int u, int v) {
    if(dep[u] < dep[v]) swap(u, v);
    for(int i = 20 ; ~ i ; -- i)
        if(dep[fa[u][i]] >= dep[v])
            u = fa[u][i];
    if(u == v) return u;
    for(int i = 20 ; ~ i ; -- i)
        if(fa[u][i] != fa[v][i])
            u = fa[u][i], v = fa[v][i];
    return fa[u][0];
}

void getdfn(int u, int fa) {
    :: fa[u][0] = fa;
    for(int i = 1 ; i <= 20 ; ++ i)
        :: fa[u][i] = :: fa[:: fa[u][i - 1]][i - 1];
    
    beg_dfn[u] = ++ clk;
    dep[u] = dep[fa] + 1;
    for(int i = _head[u] ; i ; i = _rest[i]) {
        int v = _to[i], w = _w[i];
        if(v == fa) continue;
        len[v] = len[u] + w;
        getdfn(v, u);
    }
    end_dfn[u] = clk;
}

int a[N * 10], top, root, spe[N];
int cmp(int x, int y) { return beg_dfn[x] < beg_dfn[y]; }

const int inf = 0x3f3f3f3f;
int f[N], h[N];

int head[N], rest[N * 2], to[N * 2], w[N * 2], tot;

int thev[N], thew[N], the_top;

namespace TreeDP {
    void dfs(int u, int fa) {
        f[u] = inf;
        if(spe[u]) f[u] = 0;
        for(int i = head[u] ; i ; i = rest[i]) {
            int v = to[i], w = :: w[i];
            if(v == fa) continue;
            dfs(v, u);
            f[u] = min(f[u], f[v] + w);
        }
    }
    
    void go(int u, int fa) {
        if(u == root) h[u] = inf;
        if(spe[u]) h[u] = 0;
        
        the_top = 0;
        for(int i = head[u] ; i ; i = rest[i]) {
            int v = to[i], w = :: w[i];
            if(v == fa) continue;
            thev[++ the_top] = v;
            thew[the_top] = w;
        }
        
        int themn = inf;
        for(int i = 1 ; i <= the_top ; ++ i) {
            int v = thev[i], w = thew[i];
            h[v] = h[u] + w;
            h[v] = min(h[v], themn + w);
            themn = min(themn, f[v] + w);
        }
        themn = inf;
        for(int i = the_top ; i >= 1 ; -- i) {
            int v = thev[i], w = thew[i];
            h[v] = min(h[v], themn + w);
            themn = min(themn, f[v] + w);
        }
        for(int i = head[u] ; i ; i = rest[i]) {
            int v = to[i];
            if(v == fa) continue;
            go(v, u);
        }
    }
    
    void sol(int root) {
        dfs(root, 0);
        go(root, 0);
    }
}

void add(int u, int v, int w) {
    to[++ tot] = v, :: w[tot] = w, rest[tot] = head[u], head[u] = tot;
    to[++ tot] = u, :: w[tot] = w, rest[tot] = head[v], head[v] = tot;
}

int sta[N], statop;

void dfs(int id, int l, int r) {
    int mid = (l + r) >> 1;
    
    if(que[id].size()) {
        top = 0;
        for(int i = l ; i <= r ; ++ i) {
            a[++ top] = i;
            spe[i] = 1;
        }
        for(T t: que[id]) {
            a[++ top] = t.x;
        }
        sort(a + 1, a + 1 + top, cmp);
        top = unique(a + 1, a + 1 + top) - a - 1;
        
        for(int i = top ; i >= 2 ; -- i)
            a[++ top] = getlca(a[i], a[i - 1]);
        sort(a + 1, a + 1 + top, cmp);
        top = unique(a + 1, a + 1 + top) - a - 1;
        
        tot = 0;
        for(int i = 1 ; i <= top ; ++ i)
            head[a[i]] = 0;
        root = a[1];
        
        statop = 0;
        for(int i = 1 ; i <= top ; ++ i) {
            int u = a[i];
            while(statop && end_dfn[sta[statop]] < beg_dfn[u]) -- statop;
            if(statop) {
                add(sta[statop], u, len[u] - len[sta[statop]]);
            }
            sta[++ statop] = u;
        }
        
        TreeDP :: sol(root);
        
        for(T t: que[id]) {
            int ansid = t.id, u = t.x;
            ans[ansid] = min(ans[ansid], min(f[u], h[u]));
        }
        
        for(int i = l ; i <= r ; ++ i) spe[i] = 0;
    }
    if(l != r) dfs(lc, l, mid), dfs(rc, mid + 1, r);
}

int main() {
    n = io();
    for(int i = 1, u, v, w ; i < n ; ++ i) {
        u = io(), v = io(), w = io();
        lk(u, v, w);
    }
    getdfn(1, 0);
    q = io();
    
    memset(ans, 0x3f, sizeof(int) * (q + 5));
    
    for(int i = 1, l, r, x ; i <= q ; ++ i) {
        l = io(), r = io(), x = io();
        poi(1, 1, n, l, r, (T) { i, x });
    }
    
    dfs(1, 1, n);
    for(int i = 1 ; i <= q ; ++ i) {
        io(ans[i]);
    }
}