P5443 [APIO2019]桥梁

传送门

子任务 $4$ 告诉我们可以离线搞带权并查集

从大到小枚举询问，从大到小连边

如果没有修改操作就可以过了

但是有修改，考虑最暴力的暴力，搞可撤销并查集

同样先离线，从大到小处理询问时，按原边权从大到小枚举到一条边时，如果他一直都没有修改，那么直接加入并查集

如果有修改那先不要加，枚举所有修改看看当前时间它的边权，然后如果它的边权大于等于询问权值，才加入并查集

最后还得撤销有修改的边，因为它们修改后的边权不满足从大到小

这样复杂度显然很高，因为我们每次都要撤销一堆操作，还要枚举所有修改

考虑分块，按操作数量分块

对于每个块，时间在它之前的所有操作肯定已经做完了，那么枚举修改时就少了很多枚举

同理撤销的时候也只要撤销块内的操作，每个块做完直接把相应边权更改重新排序（归并排序可以做得比较快，代码里用 $sort$ ）

然后复杂度就很可行了

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
using namespace std;
typedef long long ll;
inline int read()
{
    int x=,f=; char ch=getchar();
    while(ch<''||ch>'') { if(ch=='-') f=-; ch=getchar(); }
    while(ch>=''&&ch<='') { x=(x<<)+(x<<)+(ch^); ch=getchar(); }
    return x*f;
}
const int N=5e5+,SIZE=;//块大小自己试几次
int n,m,T;
struct edge{//边
    int u,v,w,id;
    edge (int a=,int b=,int c=,int d=) { u=a,v=b,w=c,id=d; }
    inline bool operator < (const edge &tmp) const {
        return w>tmp.w;
    }
}E[N];
struct dat{//操作
    int x,w,id;
    dat (int a=,int b=,int c=) { x=a,w=b,id=c; }
    inline bool operator < (const dat &tmp) const {
        return w>tmp.w;
    }
};
vector <dat> Q,C;//Q存询问，C存操作
int fa[N],sz[N],st[N],Top;//待撤销并查集,st维护操作序列
int find(int x) { return x==fa[x] ? x : find(fa[x]); }
inline void merge(int x,int y)//启发式合并
{
    int u=find(x),v=find(y); if(u==v) return;
    if(sz[u]<sz[v]) swap(u,v);
    fa[v]=u; sz[u]+=sz[v]; st[++Top]=v;
}
int ans[N],mx[N],id[N];//mx[i]是当前编号为i的边的权值,id[i]是编号为i的边当前的位置
void solve()
{
    sort(E+,E+m+);//每次都sort
    for(int i=;i<=m;i++) mx[i]=,id[ E[i].id ]=i; Top=;
    for(int i=;i<=n;i++) sz[i]=,fa[i]=i;
    for(dat x : C) mx[x.x]=-;//初始化，有修改的边先赋成-1
    sort(Q.begin(),Q.end()); int j=,las,p;//把询问排序
    for(dat q : Q)//从大到小枚举询问
    {
        for(;E[j].w>=q.w;j++) if(!mx[ E[j].id ]) merge(E[j].u,E[j].v);//如果此边没有修改可以直接加入并查集
        las=Top;
        for(dat x : C) mx[x.x]=E[ id[x.x] ].w;//一开始先赋成原本值
        for(dat x : C) if(x.id<q.id) mx[x.x]=x.w;//有修改且时间比询问早就修改
        //这时更改时间在后面的边的mx也更新好了
        for(dat x : C) if(mx[x.x]>=q.w) merge(E[ id[x.x] ].u,E[ id[x.x] ].v);//如果边权较大才加入并查集
        ans[q.id]=sz[ find(q.x) ];//更新答案
        while(Top>las) p=st[Top--],sz[fa[p]]-=sz[p],fa[p]=p;//撤回
    }
    for(dat x : C) E[ id[x.x] ].w=x.w;//一个块搞完把相应边权更改改
    C.clear(); Q.clear();//记得清空
}
int main()
{
    n=read(),m=read();
    for(int i=;i<=m;i++) E[i].u=read(),E[i].v=read(),E[i].w=read(),E[i].id=i;
    T=read(); int opt,cnt=; dat a;
    for(int i=;i<=T;i++)
    {
        opt=read(); a.x=read(); a.w=read(); a.id=i;
        opt== ? C.push_back(a) : Q.push_back(a);
        cnt++; if(cnt==SIZE) solve(),cnt=;
    }
    if(cnt) solve();
    for(int i=;i<=T;i++) if(ans[i]) printf("%d\n",ans[i]);
    return ;
}