Comet OJ - Contest #11 D.isaster(Kruskal重构树+倍增+dfs序+线段树区间乘)

题目

题目链接

思路来源

https://blog.csdn.net/qq_40400202/article/details/102461902?utm_source=app

题解

首先注意到，重边自环都无所谓，Kruskal并查集合并的时候，因为在同一个集合，会自然忽略掉这些

从x出发，编号不大于y，考虑Kruskal重构的时候，将u和v合并(不妨u<v)，新建一个点T，点权为max(u,v)，

再将u和v挂在T上，等价于直接把u挂在v上，故不用新开节点，直接建树，

最后从最大的编号n为树根，开始搜整棵树即可，

对于询问，倍增到编号可达最远点，dfs序拍到线段树上，区间乘，单点修改进入的时间戳in[x]

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
const int N=2e5+10,M=2e5+10,mod=998244353;
vector<int>e[N];
int h[N];
int n,m,q,u,v,w,op,x,y,par[N],tot;
int in[N],out[N],id[N],dfn;
int fa[N][20];
struct segtree{
	int n;
	struct node{int l,r,v;}e[N<<2];
	#define l(p) e[p].l
	#define r(p) e[p].r
	#define v(p) e[p].v
	void up(int p){v(p)=1ll*v(p<<1)*v(p<<1|1)%mod;}
	void bld(int p,int l,int r){
		l(p)=l;r(p)=r;
		if(l==r){v(p)=h[id[l]];return;}
		int mid=l+r>>1;
		bld(p<<1,l,mid);bld(p<<1|1,mid+1,r);
		up(p);
	}
	void init(int _n){n=_n;bld(1,1,n);}
	void chg(int p,int x,int v){
		if(l(p)==r(p)){v(p)=v;return;}
		int mid=l(p)+r(p)>>1;
		chg(p<<1|(x>mid),x,v);
		up(p);
	}
	int ask(int p,int ql,int qr){
		if(ql<=l(p)&&r(p)<=qr)return v(p);
		int mid=l(p)+r(p)>>1,res=1;
		if(ql<=mid)res=1ll*res*ask(p<<1,ql,qr)%mod;
		if(qr>mid)res=1ll*res*ask(p<<1|1,ql,qr)%mod;
		return res;
	}
}seg;
struct edge{
    int u,v,w;
    bool operator<(const edge &x){
        return w<x.w;
    }
}f[M];
int find(int x){
    return par[x]==x?x:par[x]=find(par[x]);
}
void merge(int x,int y,int w){
    x=find(x),y=find(y);
    if(x==y)return;//判了自环 也判了重边
    ++tot;
    if(x>y)swap(x,y);//按编号增序建树 显然n为根 新建max(x,y)为x、y父亲 等价于max(x,y)直接为min(x,y)父亲
    par[x]=y;
    e[y].pb(x);
    fa[x][0]=y;
}
void Kruskal(){
    sort(e+1,e+m+1);
    tot=0;//从n+1开始建虚点tot
    for(int i=1;i<=m;++i){
        u=find(f[i].u),v=find(f[i].v);
        merge(u,v,w);
        if(tot==n-1){
            break;
        }
    }
}
void init(int n){
    dfn=0;
    fa[0][0]=0;
    for(int i=1;i<=n;++i){
        par[i]=i;
        in[i]=out[i]=0;
        fa[i][0]=0;
        e[i].clear();
    }
}
void dfs(int u){
    for(int i=1;(1<<i)<=n;++i){
        fa[u][i]=fa[fa[u][i-1]][i-1];
    }
    in[u]=++dfn;
    id[dfn]=u;
    for(int v:e[u]){
        dfs(v);
    }
    out[u]=dfn;
}
int main(){
    scanf("%d%d%d",&n,&m,&q);
    //两两合并 最多多建n个虚点
    init(n);
    for(int i=1;i<=n;++i){
        scanf("%d",&h[i]);
        h[i]%=mod;
    }
    for(int i=1;i<=m;++i){
        scanf("%d%d",&u,&v);
        w=max(h[u],h[v]);
        f[i]={u,v,w};
    }
    Kruskal();
    dfs(n);//n为编号最大的rt
    seg.init(n);
    while(q--){
        scanf("%d%d%d",&op,&x,&y);
        if(op==1){
            if(x>y){
                puts("0");
                continue;
            }
            else{
                for(int i=18;i>=0;--i){
                    if(fa[x][i] && fa[x][i]<=y){
                        x=fa[x][i];
                    }
                }
                printf("%d\n",seg.ask(1,in[x],out[x]));
            }
        }
        else{
            y%=mod;
            h[x]=y;
            seg.chg(1,in[x],y);
        }
    }
    return 0;
}