bzoj 3237 连通图 - 并查集 - 线段树

Input

Output

Sample Input

4 5
1 2
2 3
3 4
4 1
2 4
3
1 5
2 2 3
2 1 2

Sample Output

Connected
Disconnected
Connected

Hint

N<=100000 M<=200000 K<=100000

---

　　题目大意 给出一个有n个节点和m条边的图，然后有k个询问，每个询问是删掉一些边，然后判断图是否连通，询问之间互相独立。

　　连通性问题通常的做法是并查集，然而并查集不支持删边，但是可以撤销上次操作，所以只能考虑把一条一条边加入并查集，为了高效的确定边是否存在，可以用一个时间戳(其实就是确定某条边在询问时是否存在)。因为存在的时间段是连续的，所以呢就用一个线段树，每个点开一个vector，记录恰好存在时间段为当前区间的的边有哪些。

　　接着开始遍历整棵树，每到一个点就把它存的边一一塞进并查集

　　1)如果不是叶节点，然后访问左右子树，访问完后O(1)撤销这个点加入的所有边

　　2)如果是叶节点，就随便找个点的最高级father(就是f[father] = father)看下它的size是否为n(然后一个操作就"水"完了)

　　因为并查集要支持撤销，所以不能压缩路径了，只能按秩合并(把小的合并到大的中)。

　　注意题目输入中的数据范围是错的(然后我就RE了一次)

Code

/**
 * bzoj
 * Problem#3237
 * Accepted
 * Time:19508ms
 * Memory:72656k
 */
#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <stack>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
const signed int inf = (signed)((1u << 31) - 1);
const signed long long llf = (signed long long)((1ull << 63) - 1);
const double eps = 1e-6;
const int binary_limit = 128;
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
template<typename T>
inline boolean readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && x != -1);
    if(x == -1) {
        ungetc(x, stdin);    
        return false;
    }
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u * 10) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
    return true;
}

typedef class SegTreeNode {
    public:
        vector< pair<int, int> > e;
        SegTreeNode *l, *r;
        
        SegTreeNode() {        }
        SegTreeNode(SegTreeNode* l, SegTreeNode* r):l(l), r(r) {        }
}SegTreeNode;

SegTreeNode pool[400000];
SegTreeNode *top = pool;
SegTreeNode null = SegTreeNode(&null, &null);

inline SegTreeNode* newnode() {
    *top = SegTreeNode(&null, &null);
    return top++;
}

typedef class union_found {
    public:
        int n;
        SegTreeNode* root;
        int* f;
        int* s;
        stack< pair<int, int> > trace;
        stack< pair<int, int> > ss;
        union_found():root(NULL) {        }
        union_found(int n):root(&null), n(n) {
            f = new int[(n + 1)];
            s = new int[(n + 1)];
            fill(s, s + n + 1, 1);
            for(int i = 0; i <= n; i++)
                f[i] = i;
        }
        
        int find(int x) {
            return (f[x] == x) ? (x) : (find(f[x]));
        }
        
        inline void unit(int fa, int so) {
            int ffa = find(fa);
            int fso = find(so);
            if(ffa == fso)    trace.push(pair<int, int>(0, 0));
            else {
                if(s[ffa] < s[fso])
                    swap(ffa, fso);
                trace.push(pair<int, int>(fso, f[fso]));
                ss.push(pair<int, int>(ffa, s[ffa]));
                s[ffa] += s[fso];
                f[fso] = ffa;
            }
        }
        
        inline void undo() {
            pair<int, int> p = trace.top();
            pair<int, int> sp = ss.top();
            trace.pop();
            if(p.first == 0)    return;
            f[p.first] = p.second;
            s[sp.first] = sp.second;
            ss.pop();
        }
        
        void update(SegTreeNode*& node, int l, int r, int ql, int qr, pair<int, int> &val) {
            if(node == &null)    node = newnode();
            if(l == ql && r == qr) {
//                printf("Update at segment [%d, %d] with the edge (%d, %d)\n", l, r, val.first, val.second);
                node->e.push_back(val);
                return;
            }
            int mid = (l + r) >> 1;
            if(qr <= mid)    update(node->l, l, mid, ql, qr, val);
            else if(ql > mid)    update(node->r, mid + 1, r, ql, qr, val);
            else {
                update(node->l, l, mid, ql, mid, val);
                update(node->r, mid + 1, r, mid + 1, qr, val);
            }
        }
        
        void query(SegTreeNode* node, int l, int r, boolean *res) {
            pair<int, int> p;
            for(int i = 0; i < (signed)node->e.size(); i++) {
                p = node->e[i];
                unit(p.first, p.second);
//                printf("Connect %d and %d\n", p.first, p.second);
            }
            if(l == r) {
                res[l] = (s[find(1)] == n);
            } else {
                int mid = (l + r) >> 1;
                query(node->l, l, mid, res);
                query(node->r, mid + 1, r, res);
            }
            for(int i = 0; i < (signed)node->e.size(); i++)
                undo();
        }
}union_found;

int n, m, q;
pair<int, int> *es;
vector<int> *exists;
union_found uf;

inline void init() {
    readInteger(n);
    readInteger(m);
    es = new pair<int, int>[(m + 1)];
    for(int i = 1; i <= m; i++) {
        readInteger(es[i].first);
        readInteger(es[i].second);
    }
    exists = new vector<int>[(m + 1)];
    readInteger(q);
    for(int i = 1, c, x; i <= q; i++) {
        readInteger(c);
        while(c--) {
            readInteger(x);
            exists[x].push_back(i);
        }
    }
}

inline void mktree() {
    uf = union_found(n);
    for(int i = 1; i <= m; i++) {
        exists[i].push_back(q + 1);
        for(int j = 0, last = 1; j < (signed)exists[i].size(); j++) {
            if(last == exists[i][j])
                last++;
            else {
//                cout << exists[i][j] << endl;
                uf.update(uf.root, 1, q, last, exists[i][j] - 1, es[i]);
                last = exists[i][j] + 1;
            }
        }
    }
}

boolean *res;
inline void solve() {
    res = new boolean[(q + 1)];
    uf.query(uf.root, 1, q, res);
    for(int i = 1; i <= q; i++)
        puts((res[i]) ? ("Connected") : ("Disconnected"));
}

int main() {
    init();
    mktree();
    solve();
    return 0;
}