ZOJ 3261 Connections in Galaxy War

题意：有n个星球(编号0到n-1)，有些星球之间有路径相连，且每个星球都有一个power值。每个星球可以求助，它会选择与它直接或间接相连的星球里power值最大的一个(如果有power最大且相等的几个星球，选择编号最小的一个星球)，如果那个星球的power值比自己大，则向其求助，否则不能求助。现在，给出两种操作query a和destroy a b，前者的意思是问星球a会向哪个星球求助(不能求助输出-1)，后者的意思是毁坏星球a和星球b之间直接连接的路径。(n <= 10^4，m <= 2*10^4，操作个数 <= 5*10^4)

解法：如果正着想很难做，但如果倒着想就很容易了。即，先将所有指令读入并保存，然后将所有指令要毁坏的路径全部毁坏，然后从最后一个指令开始操作，若指令为query则求a可以向谁求助，若指令为destroy a b则重建星球a和星球b之间的路径。这样，就是一个很裸的并查集了。

　　　由于数据范围太大，所以在读入所有指令毁坏指定边的时候，暴力会TLE。我得解决方法是，将所有连接的边保存并排序，对每条边设置一个变量表示这条边存在还是已经毁坏了，然后每次要毁坏都用二分查找。

tag:并查集, good

/*
 * Author:  Plumrain
 * Created Time:  2013-11-28 20:27
 * File Name: DS-ZOJ-3261.cpp
 */
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;

#define PB push_back
const int maxn = 10005;
const int maxm = 20005;

struct node{
    int f, r;
};

struct query{
    int s, e;
    int q;
};

struct Pat{
    int s, e;
    bool x;
};

int n, m, q;
int cost[maxn];
Pat pat[maxm];
vector<int> ans;
query ask[maxn*5];
node nod[maxn];

bool cmp(Pat a, Pat b)
{
    return a.s < b.s || (a.s == b.s && a.e < b.e);
}

bool les(int x, int y)
{
    Pat tmp;
    tmp.s = ask[y].s; tmp.e = ask[y].e;
    return cmp(pat[x], tmp);
}

int bin_search(int x)
{
    int l = 0, r = m-1;
    while (l <= r){
        int mid = (l + r) >> 1;
        if (les(mid, x)) l = mid + 1;
        else r = mid - 1;
    }
    return l;
}

void pat_del(int x)
{
    int pos = bin_search(x);
    pat[pos].x = 0;
}

void init()
{
    for (int i = 0; i < n; ++ i)
        scanf ("%d", &cost[i]);

    scanf ("%d", &m);
    for (int i = 0; i < m; ++ i){        
        scanf ("%d%d", &pat[i].s, &pat[i].e);
        if (pat[i].s > pat[i].e) swap(pat[i].s, pat[i].e);
        pat[i].x = 1;
    }

    sort(pat, pat+m, cmp);

    scanf ("%d", &q);
    char s[10];
    for (int i = 0; i < q; ++ i){
        scanf ("%s", s);
        if (s[0] == 'q'){
            ask[i].q = 0;
            scanf ("%d", &ask[i].s);
        }
        else{
            scanf ("%d%d", &ask[i].s, &ask[i].e);
            if (ask[i].s > ask[i].e) swap(ask[i].s, ask[i].e);
            pat_del(i);
            ask[i].q = 1;
        }
    }
}

int find(int x)
{
    if (x != nod[x].f){
        nod[x].f = find(nod[x].f);
        int tmp;
        if (cost[nod[x].r] > cost[nod[nod[x].f].r]) tmp = nod[x].r;
        else if (cost[nod[x].r] == cost[nod[nod[x].f].r]) tmp = min(nod[x].r, nod[nod[x].f].r);
        else tmp = nod[nod[x].f].r;
        nod[x].r = nod[nod[x].f].r = tmp;
    }
    return nod[x].f;
}

void merge(int s, int e, int t1, int t2)
{
    nod[t1].f = t2;
    int tmp;
    if (cost[nod[t1].r] > cost[nod[t2].r]) tmp = nod[t1].r;
    else if (cost[nod[t1].r] == cost[nod[t2].r]) tmp = min(nod[t1].r, nod[t2].r);
    else tmp = nod[t2].r;
    nod[t1].r = nod[t2].r = tmp;
}

void gao()
{
    for (int i = 0; i < n; ++ i)
        nod[i].r = nod[i].f = i;

    for (int i = 0; i < m; ++ i) if (pat[i].x){
        int s = pat[i].s, e = pat[i].e; 
        int t1 = find(s), t2 = find(e);
        if (t1 != t2)
            merge(s, e, t1, t2);
    }

    for (int i = q-1; i >= 0; -- i){
        if (ask[i].q == 0){
            int tmp = ask[i].s;
            int y = find(tmp);
            int tmp2 = nod[y].r;
            if (cost[tmp2] <= cost[tmp]) ans.PB (-1);
            else ans.PB (tmp2);
        }
        if (ask[i].q == 1){
            int s = ask[i].s, e = ask[i].e;
            int t1 = find(s), t2 = find(e);
            if (t1 != t2)
                merge(s, e, t1, t2);
        }
    }
}

int main()
{
    bool flag = 0;
    while (scanf ("%d", &n) != EOF){
        if (flag) printf ("
");
        flag = 1;

        init();
        ans.clear();
        gao();

        int sz = ans.size();
        for (int i = sz-1; i >= 0; -- i)
            printf ("%d
", ans[i]);
    }
    return 0;
}