CF 1417F-Graph and Queries

这次打的着实够劲，差点ak，还是做的慢了点

分享一下F题的代码，还是很好的一道题，注释有一些解释，实现起来可能比较随心所欲了一点~~~~~

#include <vector>
#include <unordered_set>
#include <cstdio>
#include <cstring>
#include <climits>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long LL;
#define pEnter putchar('\n')
#define sc(n) scanf("%d",&(n))
#define pInt(n) printf("%d\n", (n))
#define plInt(n) printf("%lld\n", (n))
#define scc(n, m) scanf("%d%d",&(n), &(m))
#define sccc(n, m, k) scanf("%d%d%d",&(n), &(m), &(k))
#define mem(arr, val) memset(arr, val, sizeof(arr))
#define pVarInt(v) printf("%s = %d\n",#v,(v))
#define rep(var, s, t) for(int var=(s); var<=(t); var++)
#define drep(var, s, t) for(int var=(s); var>=(t); var--)
inline void PrintArrInt(int arr[], int s, int e){rep(i, s, e)printf("%d%c",arr[i],i==e?'\n':' ');}

/*
    CF 1417F:
        一个无向图，有n个节点，每个节点有有一个值p, p属于[1, n]，且互不相同
        两个操作：
            1. 询问与V这个节点连通的点集中p最大是多少，输出此值后，将p最大的那个点的p设为0
            2. 断开序号为i的边

        思路： 
            此题可以看作把一个大集合不断切分，并不断询问集合内部的最大值，还要set 0
            切分太难做了
            于是想到倒叙，把一些小集合不断合并，再正过来进行询问操作(询问不能也倒过来做，因为询问了后有set 0)
            于是想到重建一棵树，每一个节点都代表着以此节点开始的子树涵盖的点集
            并在不断合并的过程中记录那些询问的点所在的点集，这个点集一定与当前的一个根节点联系，记录这个节点
            合并过程采用并查集与路径压缩
            两个集合合并时新建立一个节点，将这个点的p值设为0
            注意直到合并到最后一次，这还是一个森林
            我们还需要一个超级节点把所有树根连起来
            接下来就是dfs序建线段树，维护最大值与查询
            （可以建立一个值到线段树上一点的映射(因为每个值都不相同)，这样可以直接set 0，然后自下而上进行更新）
*/

const int maxn = 2e5 + 5;
const int maxm = 3e5 + 5;
const int maxq = 5e5 + 5;
int N, M, Q, ncnt, bcj[maxn*2];
struct Edge{
    bool isu;
    int u, v;
} es[maxm]; 
struct Que{
    int op, u, n;
} qs[maxq];
struct Node{
    int num, ls, rs;
} ns[maxn*2];
int maxv[maxn*8], tp[maxn*2], dfn[maxn*2], sz[maxn*2], val[maxn];
vector<int> ns0; unordered_set<int> se;

int _find(int u) {
    return u==bcj[u]?u: bcj[u]=_find(bcj[u]);
}

void merge(int u, int v) {
    int fu=_find(u), fv=_find(v);
    if(fu==fv) return;
    ++ncnt; 
    ns[ncnt].ls=fu, ns[ncnt].rs=fv, ns[ncnt].num=0;
    bcj[fu]=bcj[fv]=ncnt; bcj[ncnt]=ncnt;
}

int dtfn = 0;
void dfs(int u) {
    if(u==-1) {
        for(int v: ns0) dfs(v);
    }
    else {
        if(!u) return;
        dfn[u]=++dtfn;
        tp[dtfn]=ns[u].num;
        sz[u]=1;
        dfs(ns[u].ls); dfs(ns[u].rs);
        sz[u]+=sz[ns[u].ls]+sz[ns[u].rs];
    }
}

void build(int o, int L, int R) {
    if(L==R) {
        maxv[o]=tp[L]; 
        if(tp[L]) val[tp[L]]=o;
        return;
    }
    int mid=(L+R)>>1;
    build(o*2, L, mid);
    build(o*2+1, mid+1, R);
    maxv[o]=max(maxv[o*2], maxv[o*2+1]);
}

int getmax(int o, int L, int R, int lft, int rht) {
    if(L>=lft && R<=rht) return maxv[o];
    int mid=(L+R)>>1;
    int res = 0;
    if(lft<=mid) res=max(res, getmax(o*2, L, mid, lft, rht));
    if(rht>mid) res=max(res, getmax(o*2+1, mid+1, R, lft, rht));
    return res;
}

void set_update(int o) {
    maxv[o]=0;
    while(true) {
        if(o/2==0) break;
        int fa=o/2;
        maxv[fa]=max(maxv[fa*2], maxv[fa*2+1]);
        o>>=1;
    }
}

int main() {
    sccc(N, M, Q); ncnt=N;
    rep(i, 1, N) sc(ns[i].num), ns[i].ls=ns[i].rs=0, bcj[i]=i;
    rep(i, 1, M) scc(es[i].u, es[i].v), es[i].isu=true;
    rep(i, 1, Q) {
        scc(qs[i].op, qs[i].u);
        if(qs[i].op==2) es[qs[i].u].isu=false;
    }
    rep(i, 1, M) {
        if(!es[i].isu) continue;
        merge(es[i].u, es[i].v);
    }
    drep(i, Q, 1) {
        if(qs[i].op==1) qs[i].n=_find(qs[i].u);
        else merge(es[qs[i].u].u, es[qs[i].u].v);
    }
    rep(i, 1, ncnt) {
        int fa=_find(i);
        se.insert(fa);
    }
    for(int f: se) ns0.push_back(f);
    dfs(-1);
    build(1, 1, ncnt);
    rep(i, 1, Q) {
        if(qs[i].op==2) continue;
        int L=dfn[qs[i].n], R=L+sz[qs[i].n]-1;
        int res=getmax(1, 1, ncnt, L, R);
        pInt(res);
        set_update(val[res]);
    }
    return 0;
}