【LCT】Codeforces1023F Mobile Phone Network

题意：

给出n个点，你拥有k条边，这些边权值未定。还有m条权值已知的边，要求这个图的最小生成树，一定包含了所有你的边。满足这个条件下，求你拥有的边的权值最大和。（保证k条边不会形成环）

分析：

啊啊啊啊啊结果就因为多了一句$MakeRoot$操作就卡常。。。。。好亏啊。。。。。

本来可以直接跳紫上黄的。。。。5555。。。。

其实非常简单啦。。。首先拿拥有的k条边建一颗树出来，然后先按权值从小到大，插入权值已知的边（即插入后不会形成环就可以插入）。

现在就要满足：在任意一个环中，你拥有的边权一定都是最小的。

所以把那些边权已知的边，从大到小依次处理，设其端点为$u、v$，权值为$val$

那么从$u$到$v$这条路径的权值全部更改为$val$（直接更改即可，因为从大到小的顺序，所以之前有权值的一定会更大）。
最后依次求你拥有的边的权值之和即可。。。。注意这里不能MakeRoot。。。。（虽然我也不知道当时为什么要写这句）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#define SF scanf
#define PF printf
#define MAXN 1500010
#define INF 0x3FFFFFFF
typedef long long ll;
using namespace std;
struct L{
    int u,v;
    int val;
    bool operator <(const L &a) const {
        return a.val<val;   
    }
}l[MAXN];
int n,m;
struct node *NIL;
struct node{
    node *ch[2],*fa;
    int val;
    int changed;
    bool rev;
    bool Dir(){
        return this==fa->ch[1];
    }
    bool Isroot(){
        return fa==NIL||(this!=fa->ch[0]&&this!=fa->ch[1]);
    }
    void setchild(node *x,int d){
        ch[d]=x;
        if(x!=NIL)
            x->fa=this;
    }
    void pushdown(){
        if(rev){
            swap(ch[0],ch[1]);
            if(ch[0]!=NIL)
                ch[0]->rev^=1;
            if(ch[1]!=NIL)
                ch[1]->rev^=1;
            rev=0;
        }
        if(changed!=0){
            if(ch[0]!=NIL){
                ch[0]->changed=changed;
                ch[0]->val=val;
            }
            if(ch[1]!=NIL){
                ch[1]->changed=changed;
                ch[1]->val=val;
            }
            changed=0;
        }
    }
}tree[MAXN];
void Rotate(node *x){
    node *y=x->fa;
    y->pushdown(),x->pushdown();
    int d=x->Dir();
    if(y->Isroot())
        x->fa=y->fa;
    else
        y->fa->setchild(x,y->Dir());
    y->setchild(x->ch[!d],d);
    x->setchild(y,!d);
}
void Splay(node *x){
    x->pushdown();
    while(!x->Isroot()){
        node *y=x->fa;
        if(y->Isroot())
            Rotate(x);
        else{
            if(x->Dir()==y->Dir())
                Rotate(y);
            else
                Rotate(x);
            Rotate(x);
        }
    }
}
void Access(node *x){
    node *c=NIL;
    while(x!=NIL){
        Splay(x);
        x->setchild(c,1);
        c=x;
        x=x->fa;
    }
}
void MakeRoot(node *x){
    Access(x);
    Splay(x);
    x->rev^=1;
}
void Link(node *x,node *y){
    MakeRoot(x);
    x->fa=y;
}
void Cut(node *x,node *y){
    MakeRoot(x);
    Access(y);
    Splay(y);
    y->ch[0]=NIL;
    x->fa=NIL;
}
node *FindRoot(node *x){
    Access(x);
    Splay(x);
    node *y=x;
    while(y->ch[0]!=NIL)
        y=y->ch[0];
    Splay(y);
    return y;
}
bool used[MAXN];
int cnt;
void Change(int u,node *x,node *y,int val){
    if(FindRoot(x)==FindRoot(y)){
        MakeRoot(x);
        Access(y);
        Splay(y);
        y->val=val;
        y->changed=val;
    }
    else{
        Link(&tree[u+n],x);
        Link(&tree[u+n],y);
    }
}
void Newnode(node *x,int val){
    x->fa=x->ch[0]=x->ch[1]=NIL;
    x->val=val;
    x->changed=0;
}
int k,u,v,val;
int main(){
    NIL=&tree[0];
    NIL->ch[0]=NIL->ch[1]=NIL->fa=NIL;
    SF("%d",&n);
    SF("%d",&m);
    SF("%d",&k);
    for(int i=1;i<=n;i++)
        Newnode(&tree[i],0);
    for(int i=1;i<=m;i++){
        SF("%d%d",&u,&v);
        Newnode(&tree[i+n],INF);
        node *x=&tree[u];
        node *y=&tree[v];
        Link(&tree[i+n],x);
        Link(&tree[i+n],y);
    }
    for(int i=1;i<=k;i++){
        SF("%d%d%d",&u,&v,&val);
        l[i].u=u;
        l[i].v=v;
        l[i].val=val;
    }
    sort(l+1,l+1+k);
    for(int i=k;i>=1;i--){
        Newnode(&tree[i+n+m],l[i].val);
        node *x=&tree[l[i].u];
        node *y=&tree[l[i].v];
        if(FindRoot(x)!=FindRoot(y)){
            Link(&tree[i+n+m],x);
            Link(&tree[i+n+m],y);
        }
    }
    for(int i=1;i<=k;i++){
        //PF("{%d %d %d}\n",l[i].u,l[i].v,l[i].val);
        node *x=&tree[l[i].u];
        node *y=&tree[l[i].v];
        MakeRoot(x);
        Access(y);
        Splay(y);
        y->val=l[i].val;
        y->changed=l[i].val;
    }
    ll ans=0;
    for(int i=1;i<=m;i++){
        node *x=&tree[i+n];
        //MakeRoot(x);
        Access(x);
        Splay(x);
        //PF("{%d}",x->val);
        if(x->val==INF){
            PF("-1");
            return 0;
        }
        ans+=x->val;
    }
    PF("%I64d\n",ans);
}