神仙题

题目大意：

有一张\(n\)个点\(m\)条边的无向联通图，每次修改一条边的边权，问每次修改之后这张图的最小生成树权值和

话说是不是\(cdq\)题目都可以用什么数据结构莽过去啊……

这道题目确实是\(cdq\)好题

\(cdq\)分治一定要处理多维偏序问题吗？并不是，它的核心思想是一个用子问题计算对另一个子问题的贡献

我们将这道题按照时间轴来分治，那么显然一个子问题对另一个子问题是存在贡献的

我们将整张图上的边进行分类：

在当前分治区间内涉及到修改的边称为动态边

其他边称为静态边

我们在分治过程中，动态边显然会随着区间的缩小而减少，那么我们怎么来处理静态边呢？

仔细考虑，我们根本不可以发现，静态边可以分为三类：

\(1.\)无用边：肯定不会作为最小生成树中的边

对于这类边，我们可以直接扔掉

\(2.\)必要边：必作为生成树中的边

对于这种边，我们可以直接把边权计入答案，然后把边连接的两个点用并查集合并到一起

\(3.\)其他边

没什么办法了，直接传给子区间吧

按照这种方法，每分治到一个更小的区间，其他区间的动态边就会变成静态边，当我们分治到\(l==r\)时，所有的边都会变为静态边，那么其他边将不存在，必要边贡献的答案就是答案了

现在我们有两个问题：

1：如何求出前两类边？

求无用边，我们可以将所有动态边的边权设置为\(inf\)，然后跑\(Kruskal\)，最后没有被用到的静态边都是无用边

求必要边，我们可以将所有动态边的边权设置为\(-inf\),还跑\(Kruskal\)，最后被用到的静态边都是必要边

正确性好像挺显然的（雾

2：时间复杂度？

假设当前区间内有\(k\)条动态边，那么除去必要边和无用边之后，最多留下\(k+1\)个点和\(2k\)条边

由于\(k\)每次降低一倍，所以边数和点数都是都每次减少接近一倍，复杂度约为\(O(nlog^2n)\)

注意我们每次操作要先求必要边再求无用边复杂度才对！！！

我们注意这道题，它的其他子问题对当前子问题的贡献并不是按照一般\(cdq\)的方法，而是在进入当前区间之前已经将贡献计算好了

#include<bits/stdc++.h>
using namespace std;
namespace red{
#define int long long
#define mid ((l+r)>>1)
#define lowbit(x) ((x)&(-x))
    inline int read()
    {
        int x=0;char ch,f=1;
        for(ch=getchar();(ch<'0'||ch>'9')&&ch!='-';ch=getchar());
        if(ch=='-') f=0,ch=getchar();
        while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
        return f?x:-x;
    }
    const int N=1e5+10;
    int n,m,ask;
    struct edge
    {
        int x,y,val,opt;
        inline bool operator < (const edge &t) const
        {
            return val<t.val;
        }
    }a[N];
    struct moved
    {
        int x,y;
    };
    struct node
    {
        int num,val,ret;
    }q[N];
    struct dsu
    {
        int f[N],str[N];
        struct blue {int x,y;};
        stack<blue> st;
        inline void init()
        {
            for(int i=1;i<=n;++i) f[i]=i,str[i]=1;
        }
        inline int find(int k)
        {
            return f[k]==k?k:find(f[k]);
        }
        inline void merge(int x,int y)
        {
            int tx=find(x),ty=find(y);
            if(tx==ty) return;
            if(str[tx]<str[ty]) swap(tx,ty);
            str[tx]+=str[ty];
            f[ty]=tx;
            blue tmp;
            tmp.x=tx,tmp.y=ty;
            st.push(tmp);
        }
        inline void del()
        {
            blue now=st.top();
            st.pop();
            f[now.y]=now.y;
            str[now.x]-=str[now.y];
        }
        inline void clear(int bot)//可撤销并查集
        {
            while(st.size()>bot) del();
        }
    }s1,s;//s全局
    int ret[30];
    //reduction无用边  
    //contraction必须边
    vector<edge> eg[30],tr;//存每一层静态边和临时静态边
    vector<moved> rose;//存当前动态边
    int bot[30];
    bool book[N];
    inline void push_down(int dep)
    {
        tr.clear();
        for(int i=0;i<eg[dep].size();++i) tr.push_back(eg[dep][i]);
        sort(tr.begin(),tr.end());
        s1.clear(0);
        ret[dep+1]=ret[dep];
        for(int i=0;i<rose.size();++i) s1.merge(rose[i].x,rose[i].y);
        rose.clear();
        for(int tx,ty,i=0;i<tr.size();++i)//求必要边
        {
            tx=s1.find(tr[i].x),ty=s1.find(tr[i].y);
            if(tx==ty) continue;
            tr[i].opt=1;
            s1.merge(tr[i].x,tr[i].y);
            s.merge(tr[i].x,tr[i].y);
            ret[dep+1]+=tr[i].val;
        }
        s1.clear(0);//撤销
        for(int i=0;i<tr.size();++i)//求无用边
        {
            if(tr[i].opt) continue;
            if(s.find(tr[i].x)==s.find(tr[i].y)||s1.find(tr[i].x)==s1.find(tr[i].y))
            {
                tr[i].opt=-1;
                continue;
            }
            s1.merge(tr[i].x,tr[i].y);
        }
        s1.clear(0);//撤销
        eg[dep+1].clear();
        for(int tx,ty,i=0;i<tr.size();++i)
        {
            if(tr[i].opt) continue;
            tx=s.find(tr[i].x),ty=s.find(tr[i].y);
            if(tx==ty) continue;
            edge tmp;
            tmp.x=tx,tmp.y=ty,tmp.val=tr[i].val,tmp.opt=0;
            eg[dep+1].push_back(tmp);
        }
        return;
    }
    inline void cdq(int l,int r,int dep)
    {
        bot[dep]=s.st.size();
        if(l==r)
        {
            edge tmp;
            tmp.x=s.find(a[q[r].num].x),tmp.y=s.find(a[q[r].num].y);//底层
            tmp.val=q[r].val,tmp.opt=0;
            a[q[r].num].val=q[r].val;//注意这里，直接更改
            eg[dep].push_back(tmp);
            push_down(dep);
            q[r].ret=ret[dep+1];
            s.clear(bot[dep-1]);
            return;
        }
        for(int i=l;i<=mid;++i) book[q[i].num]=1;//递归左边时，右边的动态变静态
        for(int i=mid+1;i<=r;++i)
        {
            if(book[q[i].num]) continue;
            edge tmp;
            tmp.x=s.find(a[q[i].num].x),tmp.y=s.find(a[q[i].num].y);
            tmp.val=a[q[i].num].val,tmp.opt=0;
            eg[dep].push_back(tmp);
        }
        for(int i=l;i<=mid;++i)//左边的动态存进去
        {
            moved tmp;
            tmp.x=s.find(a[q[i].num].x),tmp.y=s.find(a[q[i].num].y);
            rose.push_back(tmp);
        }
        
        push_down(dep);//下放
        
        for(int i=mid+1;i<=r;++i)
        {
            if(book[q[i].num]) continue;
            eg[dep].pop_back();
        }
        for(int i=l;i<=mid;++i) book[q[i].num]=0;//回溯
        
        cdq(l,mid,dep+1);
        
        for(int i=0;i<eg[dep].size();++i) eg[dep][i].opt=0;//去掉标记
        
        for(int i=mid+1;i<=r;++i) book[q[i].num]=1;
        
        for(int i=l;i<=mid;++i)//左边的动态变静态
        {
            if(book[q[i].num]) continue;
            edge tmp;
            tmp.x=s.find(a[q[i].num].x),tmp.y=s.find(a[q[i].num].y);
            tmp.val=a[q[i].num].val,tmp.opt=0;
            eg[dep].push_back(tmp);
        }
        for(int i=mid+1;i<=r;++i)//右边的动态放进去
        {
            book[q[i].num]=0;
            moved tmp;
            tmp.x=s.find(a[q[i].num].x),tmp.y=s.find(a[q[i].num].y);
            rose.push_back(tmp);
        }
        push_down(dep);
        cdq(mid+1,r,dep+1);
        s.clear(bot[dep-1]);//撤销并查集
    }
    inline void main()
    {
        n=read(),m=read(),ask=read();
        s1.init(),s.init();
        for(int i=1;i<=m;++i) a[i].x=read(),a[i].y=read(),a[i].val=read();
        for(int i=1;i<=ask;++i)
        {
            q[i].num=read(),q[i].val=read();
            book[q[i].num]=1;
        }
        for(int i=1;i<=m;++i)
        {
            if(book[i]) continue;
            eg[1].push_back(a[i]);
        }
        for(int i=1;i<=ask;++i) book[q[i].num]=0;
        cdq(1,ask,1);
        for(int i=1;i<=ask;++i) printf("%lld\n",q[i].ret);
    }
}
signed main()
{
    red::main();
    return 0;
}