BZOJ4046 [Cerc2014] Pork barre

我们把边按权值从大到小依次加入图中

如果加到边权$V$，则当前的最小生成森林中边权$vin[V, V']$(其中$V'$是任意值)形成的森林的边权和就是对于询问$[V, V']$的答案

由于点数不多，所以可以每次暴力$dfs$找环上最大边以及暴力删除。。。

又由于是强制在线，于是用可持久化线段树维护不同权值的出现次数即可

/**************************************************************
    Problem: 4046
    User: rausen
    Language: C++
    Result: Accepted
    Time:8788 ms
    Memory:46132 kb
****************************************************************/
 
#include <cstdio>
#include <cstring>
#include <algorithm>
 
using namespace std;
const int N = 1e3 + 5;
const int M = 1e5 + 5;
const int maxV = 1e6 + 5;
 
int read();
 
struct Edge {
    int x, y, v;
     
    inline bool operator < (const Edge &e) const {
        return v > e.v;
    }
     
    inline void get() {
        x = read(), y = read(), v = read();
    }
} E[M];
 
struct edge {
    int next, to, v;
    edge() {}
    edge(int _n, int _t, int _v) : next(_n), to(_t), v(_v) {}
} e[M << 1];
 
struct chair_tree {
    chair_tree *ls, *rs;
    int sum;
     
    #define Cnt 3500000
    inline void* operator new(size_t, chair_tree *_c = NULL, int f = 0) {
        static chair_tree mempool[Cnt], *c;
        if (f) c = mempool;
        if (_c == NULL)
            c -> ls = c -> rs = NULL, c -> sum = 0;
        else *c = *_c;
        return c++;
    }
    #undef Cnt
     
    #define mid (l + r >> 1)
    void modify(int l, int r, int pos, int d) {
        sum += d;
        if (l == r) return;
        if (pos <= mid) {
            ls = new(ls)chair_tree;
            ls -> modify(l, mid, pos, d);
        } else {
            rs = new(rs)chair_tree;
            rs -> modify(mid + 1, r, pos, d);
        }
    }
     
    int query(int l, int r, int L, int R) {
        if (L <= l && r <= R) return sum;
        int res = 0;
        if (ls && L <= mid) res += ls -> query(l, mid, L, R);
        if (rs && mid < R) res += rs -> query(mid + 1, r, L, R);
        return res;
    }
    #undef mid
} *root[M];
 
int n, m, ans;
int first[N], tot;
int fa[N];
int tmp[M], len;
 
inline void Add_Edges(int x, int y, int v) {
    e[++tot] = edge(first[x], y, v), first[x] = tot;
    e[++tot] = edge(first[y], x, v), first[y] = tot;
}
 
#define y e[x].to
inline void Delete_Edge(int p, int q) {
    int x;
    if (e[first[p]].to == q) {
        first[p] = e[first[p]].next;
        return;
    }
    for (x = first[p]; x; x = e[x].next)
        if (e[e[x].next].to == q) {
            e[x].next = e[e[x].next].next;
            return;
        }
}
 
inline void Delete_Edges(int p, int q) {
    Delete_Edge(p, q);
    Delete_Edge(q, p);
}
 
int find_max(int p, int fa, int tar) {
    int x, tmp;
    for (x = first[p]; x; x = e[x].next)
        if (y != fa) {
            if (y == tar) return x;
            tmp = find_max(y, p, tar);
            if (tmp != -1) {
                if (e[tmp].v > e[x].v) return tmp;
                return x;
            }
        }
    return -1;
}
#undef y
 
int find(int x) {
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
 
inline int get(int x) {
    return lower_bound(tmp + 1, tmp + len + 1, x) - tmp;
}
 
int main() {
    int T, now, i, x, y, Q;
    for (T = read(); T; --T) {
        n = read(), m = read(), ans = 0;
        for (i = 1; i <= n; ++i) fa[i] = i;
        for (i = 1; i <= m; ++i) {
            E[i].get();
            tmp[i] = E[i].v;
        }
        sort(E + 1, E + m + 1);
        sort(tmp + 1, tmp + m + 1), len = unique(tmp + 1, tmp + m + 1) - tmp - 1;
        memset(first, 0, sizeof(first)), tot = 1;
         
        root[len + 1] = new(NULL, 1)chair_tree;
        for (now = len, i = 1; now; --now) {
            root[now] = new(root[now + 1])chair_tree;
            for (; E[i].v == tmp[now] && i <= m; ++i) {
                x = find(E[i].x), y = find(E[i].y);
                if (x != y) fa[x] = y;
                else {
                    x = find_max(E[i].x, 0, E[i].y);
                    Delete_Edges(e[x].to, e[x ^ 1].to);
                    root[now] -> modify(1, len, get(e[x].v), -e[x].v);
                }
                Add_Edges(E[i].x, E[i].y, E[i].v);
                root[now] -> modify(1, len, get(E[i].v), E[i].v);
            }
        }
        for (Q = read(); Q; --Q) {
            x = read(), y = read();
            x = upper_bound(tmp + 1, tmp + len + 1, x - ans - 1) - tmp;
            y = upper_bound(tmp + 1, tmp + len + 1, y - ans) - tmp - 1;
            if (x > y) printf("%d
", ans = 0);
            else printf("%d
", ans = root[x] -> query(1, len, x, y));
        }
    }
    return 0;
}
 
inline int read() {
    static int x;
    static char ch;
    x = 0, ch = getchar();
    while (ch < '0' || '9' < ch)
        ch = getchar();
    while ('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x;
}