bzoj 3669 魔法森林 LCT

题目地址

//#include <bits/stdc++.h>
#include<stdio.h>
#include<string.h>
#include<string>
#include<math.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<stdlib.h>
#include<time.h>
#include <iomanip>
#define lowbit(x) (x&(-x))
#define inf  0x7fffffff
#define linf 0x7fffffffffffffff
#define mem(x,y) memset(x,y,sizeof(x))
#define fup(i,x,y) for(int i=(x);i<=(y);i++)
#define fdn(i,x,y) for(int i=(x);i>=(y);i--)
#define sp(x) setprecision(x)
#define sd(n) scanf("%d",&n)
#define sdd(n,m) scanf("%d%d",&n,&m)
#define sddd(n,m,k) scanf("%d%d%d",&n,&m,&k)
#define sld(n) scanf("%lld",&n)
#define sldd(n,m) scanf("%lld%lld",&n,&m)
#define slddd(n,m,k) scanf("%lld%lld%lld",&n,&m,&k)
#define sf(n) scanf("%lf",&n)
#define sff(n,m) scanf("%lf%lf",&n,&m)
#define sfff(n,m,k) scanf("%lf%lf%lf",&n,&m,&k)
#define sc(n) scanf("%s",n)
#define pf(x) printf("%d\n",x)
#define pfl(x) printf("%lld\n",x)
#define pff(x) printf("%lf\n",x)
#define debug printf("!!\n");
#define N 1000000
#define M 1000000
#define pi acos(-1)
#define eps 1e-2
//cout.setf(ios::fixed);
//freopen("out.txt","w",stdout);// freopen("in.txt","r",stdin);
using namespace std;
typedef long long  ll;
typedef double db;
const int mod=1e9+7;
class node
{
    public:int fa,son[2],ma,num,data;
    bool is_root,Reverse;
    void ini()
    {
        is_root=1;
        fa=son[0]=son[1]=Reverse=ma=num=data=0;
    }
}t[N+M];
struct edges
{
    int x,y,a,b;
    void read()
    {
        sdd(x,y);
        sdd(a,b);
    }
    bool operator<(const edges b) const
    {
        return a<b.a;
    }
}e[N+M];
int n,m;
void pushreverse(int x)
{
    if(!x) return ;
    swap(t[x].son[0],t[x].son[1]);
    t[x].Reverse^=1;
}
void update(int x)
{
    t[x].num=x;
    t[x].ma=t[x].data;
    int l=t[x].son[0],r=t[x].son[1];
    if(l&&t[l].ma>t[x].ma) t[x].ma=t[l].ma,t[x].num=t[l].num;
    if(r&&t[r].ma>t[x].ma) t[x].ma=t[r].ma,t[x].num=t[r].num;
}
void pushdown(int x)
{
    if(t[x].Reverse)
    {
        pushreverse(t[x].son[0]);
        pushreverse(t[x].son[1]);
        t[x].Reverse=false;
    }
}
int get(int x)
{
    return x==t[t[x].fa].son[1];
}
void Rotate(int x)
{
    if(t[x].is_root) return;
    int k=get(x),fa=t[x].fa,fafa=t[fa].fa;
    t[fa].son[k]=t[x].son[k^1];
    if(t[x].son[k^1]) t[t[x].son[k^1]].fa=fa;
    t[x].son[k^1]=fa;
    t[fa].fa=x;
    t[x].fa=fafa;
    if(!t[fa].is_root) t[fafa].son[fa==t[fafa].son[1]]=x;
    else t[x].is_root=true,t[fa].is_root=false;
    update(fa),update(x);
}
void push(int x)
{
    if(!t[x].is_root) push(t[x].fa);
    pushdown(x);
}
void splay(int x)
{
    push(x);
    for(int fa;!t[x].is_root;Rotate(x))
    {
        if(!t[fa=t[x].fa].is_root) Rotate(get(x)==get(fa)?fa:x);
    }
}
void access(int x)
{
    int y=0;
    do
    {
        splay(x);
        t[t[x].son[1]].is_root=true;
        t[t[x].son[1]=y].is_root=false;
        update(x);
        x=t[y=x].fa;
    }while(x);
}
void mroot(int x)
{

    access(x);
    splay(x);
    pushreverse(x);
}
void link(int u,int v)
{
    mroot(u);
    t[u].fa=v;
    update(u);
}
void cut(int u,int v)
{
	mroot(u);
	access(v);
	splay(v);
	t[u].is_root=true;
	t[u].fa=t[v].son[0]=0;
}
void cut1(int u,int v)
{
	mroot(u);
	access(v);
	splay(v);
	int l=t[v].son[0];
	t[l].is_root=true;
	t[l].fa=t[v].son[0]=0;
}
int fa[N+M];
int findf(int x)
{
    return fa[x]==x? x: fa[x]=findf(fa[x]);
}
int main()
{
    sdd(n,m);
    fup(i,1,n+m)
        t[i].ini();
    fup(i,1,m)
        e[i].read();
    sort(e+1,e+1+m);
    fup(i,1,m)
        t[i+n].data=t[i+n].ma=e[i].b;
    int ans=inf;
    fup(i,1,n+m)
        fa[i]=i;
    fup(i,1,m)
    {
        if(e[i].x==e[i].y) continue;
        int x=findf(e[i].x),y=findf(e[i].y);
        if(x!=y)
        {
            link(e[i].x,i+n);
            link(e[i].y,i+n);
            fa[x]=fa[y]=findf(i+n);
        }
        else
        {
            mroot(e[i].x);
            access(e[i].y);
            splay(e[i].y);
            int xx=t[e[i].y].num;
            if(e[i].b<t[xx].data)
            {
                cut1(e[i].x,xx);
                cut1(e[i].y,xx);
                link(e[i].x,i+n);
                link(e[i].y,i+n);
            }
        }

        if(findf(1)==findf(n))
        {
            mroot(1);
            access(n);
            splay(n);
            ans=min(ans,t[n].ma+e[i].a);
        }
    }
    pf(ans==inf? -1:ans);
    char c[15];
}