Gym - 101194G Pandaria （并查集+倍增+线段树合并）

 

题意：

给定一个无向图。每个点有一种颜色。现在给定q个询问，每次询问x和w，求所有能通过边权值不超过w的边走到x的点的集合中，哪一种颜色的点出现的次数最多。次数相同时输出编号最小的那个颜色。强制在线。

 

解题思路：膜拜大神们的代码！看了好久，终于搞懂了。

 

我们假设有一个二维数组存储了所有答案ans[x][w]，那么对于每次查询，我们直接输出答案即可。关键在于怎么快速计算这个数组。我们先把图看成没有边的图，然后用克鲁斯卡尔最小生成树的思想，一条边一条边的加入，然后用并查集维护联通性。我们先从小枚举边，然后把该边插入图中。假设这条边的权值为2，那么这个时候，对于ans[x][2]，我们可以用做一遍深搜就能计算出所有的ans[x][2]。怎么快速计算呢？我们可以用线段树去求，直接查询最大值即可。每个下标记录那个颜色的数量。每深搜到一个点就把该点插入到线段树，然后查询即可。但是这样总的复杂度还是O(NMlogN)的，仍然不可接受。这时候有一种神级做法，我们在做最小生成树的过程的时候，对于每一条 边新建一个节点，然后向边的两个节点连边，然后这个点通过线段树合并，继承那两个节点的信息。这样最后会形成一棵树，这棵树从底往上就是w从小到大的过程。最后对于每个查询，我们直接倍增看看能走到多高即可。

 

#include <iostream>
#include <cstring>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=210005,MAXM=200005;

int N,M;
struct edge{
    int u,v,w;
    bool operator < (const edge &b)const{
        return w<b.w;
    }
}e[MAXM];

int pre[MAXN*2];
int find(int x){
    return x==pre[x]?x:pre[x]=find(pre[x]);
}

int root[MAXN*2];
int ls[MAXN*20];
int rs[MAXN*20];
int tree[MAXN*20];
int val[MAXN*20];
int tot=0;


void pushup(int rt){
    if(tree[ls[rt]]>=tree[rs[rt]])//>=自然求得的就是数字最小的
    {
        tree[rt]=tree[ls[rt]];
        val[rt]=val[ls[rt]];
    }
    else{
        tree[rt]=tree[rs[rt]];
        val[rt]=val[rs[rt]];
    }
}

void update(int L,int l,int r,int &rt){
    if(!rt)
        rt=++tot;
    if(l==r){
        tree[rt]=1;
        val[rt]=L;
        return;
    }
    int m=(l+r)/2;
    if(L<=m)
        update(L,l,m,ls[rt]);
    if(L>m)
        update(L,m+1,r,rs[rt]);
    pushup(rt);
}

int merge(int L,int R,int l,int r){
    if(!L||!R)
        return L+R;
    if(l==r){
        tree[L]+=tree[R];
        return L;
    }
    int m=(l+r)/2;
    ls[L]=merge(ls[L],ls[R],l,m);
    rs[L]=merge(rs[L],rs[R],m+1,r);
    pushup(L);
    return L;
}

int query(int rt){
    return val[rt];
}

int col[MAXN*3];
int ans[MAXN*3];

int dep[MAXN],fa[MAXN][20];
void init(){
   for(int i=0;i<MAXM;i++){
       pre[i]=i;
       root[i]=0;
   }
   tot=0;
   memset(ls,0,sizeof(ls));
   memset(rs,0,sizeof(rs));
   memset(tree,0,sizeof(tree));
   memset(val,0,sizeof(val));
   memset(fa,0,sizeof(fa));
}

int P;
int ch[MAXN][2];
void kruskal(){
    P=N;
    sort(e,e+M);
    for(int i=0;i<M;i++){
        int u=e[i].u;
        int v=e[i].v;
        int fx=find(u);
        int fy=find(v);
        if(fx!=fy){
            col[++P]=e[i].w;
            ch[P][0]=fx;
            ch[P][1]=fy;
            pre[fx]=P;
            pre[fy]=P;

        }
    }
}

void dfs(int u,int p){
    fa[u][0]=p;
    dep[u]=dep[p]+1;
    for(int i=1;i<20;i++)
        fa[u][i]=fa[fa[u][i-1]][i-1];
    if(u<=N)
        return;
    dfs(ch[u][0],u);
    dfs(ch[u][1],u);
    root[u]=merge(root[ch[u][0]],root[ch[u][1]],1,N);
    ans[u]=query(root[u]);
}

int find(int x,int w){
    for(int i=19;i>=0;i--)
        if(col[fa[x][i]]<=w&&fa[x][i]!=0)
            x=fa[x][i];
    return x;
}

int main(){

    int T;
    scanf("%d",&T);
    for(int qqq=1;qqq<=T;qqq++){

        init();
        scanf("%d%d",&N,&M);
        for(int i=1;i<=N;i++){
            scanf("%d",&col[i]);
            ans[i]=col[i];
            update(col[i],1,N,root[i]);
        }

        for(int i=0;i<M;i++)
            scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);

        kruskal();
        dfs(P,0);

        printf("Case #%d:\n",qqq);
        int Q;
        scanf("%d",&Q);
        int last=0;
        while(Q--){
            int u,x;
            scanf("%d%d",&u,&x);
            u=u^last;
            x=x^last;
            printf("%d\n",last=ans[find(u,x)]);
        }
    }

    return 0;
}