洛谷P3242 接水果

关于矩形与点其实有两种关系。

一种是每个矩形包含多少点。一种是每个点被多少矩形包含。

 

---

 

解：因为可以离线所以直接套整体二分。关键是考虑如何能够被覆盖。

我一开始都是想的树上操作...其实是转化成DFS序。分链和有lca两种情况。

考虑每个盘子能接住的水果，两端DFS序满足的性质。发现是二维平面上的矩形。

一个水果就是询问一个点被多少矩形覆盖(能被多少盘子接)。于是整体二分里面扫描线，片改点查用树状数组。

 

#include <bits/stdc++.h>

const int N = 80010;

struct Edge {
    int nex, v;
}edge[N << 1]; int tp;

int e[N], pos[N], ed[N], num, n, fa[N][20], pw[N], d[N]; /// tree
int X[N], xx, ans[N];

struct Node {
    int id, x, y, k, z;
    Node(int ID = 0, int X = 0, int Y = 0, int K = 0, int Z = 0) {
        id = ID;
        x = X;
        y = Y;
        k = K;
        z = Z;
    }
    inline bool operator <(const Node &w) const {
        if(id != w.id) return id < w.id;
        return z < w.z;
    }
}node[N], t1[N], t2[N], stk[N << 2];

namespace ta {
    int ta[N];
    inline void add(int x, int v) {
        for(int i = x; i <= n + 1; i += (i & (-i))) {
            ta[i] += v;
        }
        return;
    }
    inline int ask(int x) {
        int ans = 0;
        for(int i = x; i >= 1; i -= (i & (-i))) {
            ans += ta[i];
        }
        return ans;
    }
    inline void del(int x) {
        for(int i = x; i <= n + 1; i += (i & (-i))) {
            ta[i] = 0;
        }
        return;
    }
}

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS(int x, int f) {
    pos[x] = ++num;
    fa[x][0] = f;
    d[x] = d[f] + 1;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) continue;
        DFS(y, x);
    }
    ed[x] = num;
    return;
}

inline void prework() {
    for(int i = 2; i <= n; i++) pw[i] = pw[i >> 1] + 1;
    for(int j = 1; j <= pw[n]; j++) {
        for(int i = 1; i <= n; i++) {
            fa[i][j] = fa[fa[i][j - 1]][j - 1];
        }
    }
    return;
}

inline int lca(int x, int y) {
    if(d[x] > d[y]) std::swap(x, y);
    int t = pw[n];
    while(t >= 0 && d[y] > d[x]) {
        if(d[fa[y][t]] >= d[x]) {
            y = fa[y][t];
        }
        t--;
    }
    if(x == y) return x;
    t = pw[n];
    while(t >= 0 && fa[x][0] != fa[y][0]) {
        if(fa[x][t] != fa[y][t]) {
            x = fa[x][t];
            y = fa[y][t];
        }
        t--;
    }
    return fa[x][0];
}

inline int getPos(int x, int y) {
    int t = pw[n];
    while(t >= 0 && fa[y][0] != x) {
        if(d[fa[y][t]] > d[x]) {
            y = fa[y][t];
        }
        t--;
    }
    return y;
}

void Div(int L, int R, int l, int r) {
    if(L > R) return;
    if(l == r) {
        for(int i = L; i <= R; i++) {
            if(node[i].id) ans[node[i].id] = r;
        }
        return;
    }

    int mid = (l + r) >> 1, top1 = 0, top2 = 0, top = 0;
    for(int i = L; i <= R; i++) {
        int x = node[i].x, y = node[i].y, z = node[i].z;
        if(!node[i].id) { /// change  |  this is a Matrix
            if(node[i].k > mid) {
                t2[++top2] = node[i];
                continue;
            }
            t1[++top1] = node[i];
            if(z) { /// line
                stk[++top] = Node(1, pos[y], ed[y], 1, 0);
                stk[++top] = Node(pos[z], pos[y], ed[y], -1, 0);
                stk[++top] = Node(pos[y], ed[z] + 1, n, 1, 0);
                stk[++top] = Node(ed[y] + 1, ed[z] + 1, n, -1, 0);
            }
            else { /// lca
                stk[++top] = Node(pos[x], pos[y], ed[y], 1, 0);
                stk[++top] = Node(ed[x] + 1, pos[y], ed[y], -1, 0);
            }
        }
        else { /// ask  |  this is a Point
            stk[++top] = Node(pos[x], 0, pos[y], i, 1);
        }
    }
    std::sort(stk + 1, stk + top + 1);
    for(int i = 1; i <= top; i++) {
        if(stk[i].z == 0) { /// change
            ta::add(stk[i].x, stk[i].k);
            ta::add(stk[i].y + 1, -stk[i].k);
        }
        else { /// ask
            int t = ta::ask(stk[i].y), id = stk[i].k;
            if(node[id].k <= t) {
                t1[++top1] = node[id];
            }
            else {
                node[id].k -= t;
                t2[++top2] = node[id];
            }
        }
    }
    for(int i = 1; i <= top; i++) { /// clear
        if(stk[i].z == 0) {
            ta::del(stk[i].x);
            ta::del(stk[i].y + 1);
        }
    }
    memcpy(node + L, t1 + 1, top1 * sizeof(Node));
    memcpy(node + L + top1, t2 + 1, top2 * sizeof(Node));
    Div(L, L + top1 - 1, l, mid);
    Div(L + top1, R, mid + 1, r);
    return;
}

int main() {
    int m, q;
    scanf("%d%d%d", &n, &m, &q);
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d", &x, &y);
        add(x, y); add(y, x);
    }
    DFS(1, 0);
    prework();
    for(int i = 1, x, y, z; i <= m; i++) {
        scanf("%d%d%d", &x, &y, &X[i]);
        if(pos[x] > pos[y]) std::swap(x, y);
        z = lca(x, y);
        node[i] = Node(0, x, y, X[i], (z == x) ? getPos(x, y) : 0);
    }
    std::sort(X + 1, X + n + 1);
    xx = std::unique(X + 1, X + n + 1) - X - 1;
    for(int i = 1; i <= m; i++) {
        node[i].k = std::lower_bound(X + 1, X + xx + 1, node[i].k) - X;
    }
    for(int i = 1, x, y, k; i <= q; i++) {
        scanf("%d%d%d", &x, &y, &k);
        if(pos[x] > pos[y]) std::swap(x, y);
        node[m + i] = Node(i, x, y, k, 0);
    }
    Div(1, m + q, 1, xx);
    for(int i = 1; i <= q; i++) printf("%d\n", X[ans[i]]);
    return 0;
}