[APIO 2019]桥梁[分块][可撤销并查集]

桥梁

题面

考虑暴力。有一种可行方法是每次询问操作遍历边，通过加入并查集并获得并查集大小的方法完成，预计得分 13 pts

再考虑暴力。若没有修改操作，很容易想到把询问排序再把边排序后一个一个添加边来解决，那么如果有修改呢？

思路同上，将边按有无修改分开，无修改的同上，遍历询问操作，每次询问操作遍历所有修改操作，若修改操作比询问操作出现早则修改，再类似于第一种暴力地加并查集，一次询问操作后都撤销掉并查集，预计得分 13 pts

两种方法的速度分别取决于修改量和询问量，考虑将两种方法合并到一块，使各自要操作的部分的修改量或询问量都不太高

考虑操作分块

分成若干个大小为 S 的块

对于块内操作离线后照抄暴力2

处理完一个块后用暴力1 的方法直接修改边权

复杂度有点毒瘤没算

Code:

#include <ctime>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
#define inf 100010
#define INF 0x7fffffff
#define ll long long

// const unsigned int size = 500;
unsigned int size = 0;

namespace io {
    const int SIZE = (1 << 21) + 1;
    char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55]; int f, qr;
    
    #define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
    
    inline void flush () {
        fwrite (obuf, 1, oS - obuf, stdout);
        oS = obuf;
    }
    
    inline void putc (char x) {
        *oS ++ = x;
        if (oS == oT) flush ();
    }
    
    template <class I>
    inline void read (I &x) {
        for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
        for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15); 
        x *= f;
    }
    
    template <class I>
    inline void print (I x) {
        if (!x) putc ('0'); 
        if (x < 0) putc ('-'), x = -x;
        while (x) qu[++ qr] = x % 10 + '0',  x /= 10;
        while (qr) putc (qu[qr --]);
    }
    
    struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
}
using io :: read; using io :: putc; using io :: print;
template <class I>
inline void read(I &a, I &b) {read(a); read(b);}
template <class I>
inline void read(I &a, I &b, I &c) {read(a); read(b); read(c);}

struct edge {
    int from;
    int to;
    int val;
    int id;
    inline void made(int f, int t, int v, int i) {
        from = f, to = t, val = v, id = i;
    }
};
edge e[inf];
int indexEdge;

inline void connect(int from, int to, int val, int id){
    ++indexEdge;
    e[indexEdge].made(from, to, val, id);
    return;
}

struct opera {
    int id;
    int opt;
    int pos;
    int dis;
    inline void made(int i, int t, int p, int d) {
        id = i, opt = t, pos = p, dis = d;
    }
};
std::vector <opera> Opt;

int n, m, q;

int ans[inf];

namespace dsu { // dsu with back()
    struct Node {
        int first;
        int second;
    };

    int fa[inf], sz[inf];
    std::vector <Node> stack;

    inline void init(int n) {
        stack.clear();
        for(int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1;
        return;
    }
    
    int find(int f) {
        return fa[f] == f ? f : find(fa[f]);
    }

    inline void Union(int a, int b) {
        int af = find(a), bf = find(b);
        if(af == bf) return;
        if(sz[af] < sz[bf]) std::swap(af, bf);
        sz[af] += sz[bf];
        fa[bf] = af;
        stack.push_back((Node){af, bf});
        return;
    }

    inline void back(unsigned int goal) {
        while(stack.size() > goal) {
            int u = stack.back().first, v = stack.back().second;
            fa[v] = v;
            sz[u] -= sz[v];
            stack.pop_back();
        }
        return;
    }
}

inline bool cmpEdge(const edge& a, const edge& b) {
    return (a.val == b.val) ? (a.id < b.id) : (a.val > b.val);
}

inline bool cmpOpera(const opera& a, const opera& b) {
    return a.dis > b.dis;
}

bool repair[inf]; // Does this edge need to repair
int reid[inf];
int val[inf]; // the val of edges when querying
std::vector <opera> opt1, opt2;
std::vector <edge> tmp1, tmp2;

inline void solve() {
    std::fill(repair, repair + 1 + m, 0);
    dsu::init(n);
    opt1.clear(), opt2.clear();

    for(std::vector <opera> :: iterator it = Opt.begin(); it != Opt.end(); it++) {
        if(it->opt == 1) opt1.push_back(*it), repair[it->pos] = 1;
        else opt2.push_back(*it);
    }
    
    std::sort(opt2.begin(), opt2.end(), cmpOpera);

    for(int i = 1; i <= m; i++) reid[e[i].id] = i;

    int j = 1;
    for(std::vector <opera> :: iterator it = opt2.begin(); it != opt2.end(); it++) {
        // dsu the edges that will be never changed
        while(j <= m && e[j].val >= it->dis) {
            if(repair[e[j].id] == 0) dsu::Union(e[j].to, e[j].from);
            ++j;
        }
        int now = dsu::stack.size();
        // copy the init val of each edge
        for(std::vector <opera> :: iterator iter = opt1.begin(); iter != opt1.end(); iter++) {
            val[iter->pos] = e[reid[iter->pos]].val;
        }
        // execute the changes that are before this query
        for(std::vector <opera> :: iterator iter = opt1.begin(); iter != opt1.end(); iter++) {
            if(iter->id < it->id) val[iter->pos] = iter->dis;
        }
        for(std::vector <opera> :: iterator iter = opt1.begin(); iter != opt1.end(); iter++) {
            if(val[iter->pos] >= it->dis)
                dsu::Union(e[reid[iter->pos]].from, e[reid[iter->pos]].to);
        }
        ans[it->id] = dsu::sz[dsu::find(it->pos)];
        dsu::back(now);
    }
    // execute the changes in this block
    for(std::vector <opera> :: iterator iter = opt1.begin(); iter != opt1.end(); iter++) {
        e[reid[iter->pos]].val = iter->dis;
    }

    tmp1.clear(), tmp2.clear();
    for(int i = 1; i <= m; i++) {
        if(repair[e[i].id]) tmp1.push_back(e[i]);
        else tmp2.push_back(e[i]);
    }
    
    std::sort(tmp1.begin(), tmp1.end(), cmpEdge);
    std::merge(tmp1.begin(), tmp1.end(), tmp2.begin(), tmp2.end(), e + 1, cmpEdge);
    return;
}

inline void setting();

int main () {
    setting();
    read(n, m);
    size = 500;
    // size = sqrt(1.0 * n * log2(1.0 * n));
    for(int i = 1; i <= m; i++) {
        int u, v, w;
        read(u, v, w);
        connect(u, v, w, i);
    }
    std::sort(e + 1, e + 1 + m, cmpEdge);
    read(q);
    for(int i = 1; i <= q; i++) {
        int opt, a, b;
        read(opt, a, b);
        Opt.push_back((opera){i, opt, a, b});
        if(Opt.size() == size) {
            solve();
            Opt.clear();
        }
    }
    if(Opt.size()) solve();
    for(int i = 1; i <= q; i++) {
        if(ans[i]) printf("%d\n", ans[i]);
    }
    return 0;
}

inline void setting(){
#ifndef ONLINE_JUDGE
    freopen("_test.in", "r", stdin);
    freopen("_test.out", "w", stdout);
#endif
    return;
}