[bzoj 3669--NOI2014]魔法森林

为了得到书法大家的真传，小E同学下定决心去拜访住在魔法森林中的隐士。魔法森林可以被看成一个包含个N节点M条边的无向图，节点标号为1..N，边标号为1..M。初始时小E同学在号节点1，隐士则住在号节点N。小E需要通过这一片魔法森林，才能够拜访到隐士。
魔法森林中居住了一些妖怪。每当有人经过一条边的时候，这条边上的妖怪就会对其发起攻击。幸运的是，在号节点住着两种守护精灵：A型守护精灵与B型守护精灵。小E可以借助它们的力量，达到自己的目的。
只要小E带上足够多的守护精灵，妖怪们就不会发起攻击了。具体来说，无向图中的每一条边Ei包含两个权值Ai与Bi。若身上携带的A型守护精灵个数不少于Ai，且B型守护精灵个数不少于Bi，这条边上的妖怪就不会对通过这条边的人发起攻击。当且仅当通过这片魔法森林的过程中没有任意一条边的妖怪向小E发起攻击，他才能成功找到隐士。
由于携带守护精灵是一件非常麻烦的事，小E想要知道，要能够成功拜访到隐士，最少需要携带守护精灵的总个数。守护精灵的总个数为A型守护精灵的个数与B型守护精灵的个数之和。

这道题可以算是一道LCT的经典题目。我们从简单开始考虑，如果只有一维，我们就可以用最小生成树解决。那二维的基本思想其实也没多大变化，我们先按第一维排序一下，使第一维影响消去，那第二维用LCT维护之。不断加边，如果当前两点已联通，则找出当前两点之间的最大值，如果比当前的b值要大，则删掉之前联通两点之间的边，加上当前的边，否则就不管当前的边。那这道题就解决了。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
using namespace std;
struct node
{
    int f,sd,son[2];
    bool lazy;
    node(){f=son[0]=son[1]=0;lazy=false;}
}tr[201000];
int a[201000];
void update(int x)
{
    int lc=tr[x].son[0],rc=tr[x].son[1];
    tr[x].sd=x;
    if(a[tr[lc].sd]>a[tr[x].sd])tr[x].sd=tr[lc].sd;
    if(a[tr[rc].sd]>a[tr[x].sd])tr[x].sd=tr[rc].sd;
}
void reverse(int x)
{
    tr[x].lazy=false;
    swap(tr[x].son[0],tr[x].son[1]);
    int lc=tr[x].son[0],rc=tr[x].son[1];
    tr[lc].lazy=1-tr[lc].lazy;
    tr[rc].lazy=1-tr[rc].lazy;
}
void rotate(int x,int w)
{
    int f=tr[x].f,ff=tr[f].f;
    int R,r;
    R=f,r=tr[x].son[w];
    tr[R].son[1-w]=r;
    if(r!=0)tr[r].f=R;
    R=ff,r=x;
    if(tr[R].son[0]==f)tr[R].son[0]=r;
    if(tr[R].son[1]==f)tr[R].son[1]=r;
    tr[r].f=R;
    R=x,r=f;
    tr[R].son[w]=r;
    tr[r].f=R;
    update(f);update(x);
}
int tmp[201000];
void splay(int x,int rt)
{
    int s=x,ss=0;
    while(tr[s].f!=rt && (tr[tr[s].f].son[0]==s || tr[tr[s].f].son[1]==s))
    {
        tmp[++ss]=s;
        s=tr[s].f;
    }
    tmp[++ss]=s;
    while(ss)
    {
        s=tmp[ss--];
        if(tr[s].lazy==true)reverse(s);
    }
    while(tr[x].f!=rt && (tr[tr[x].f].son[0]==x || tr[tr[x].f].son[1]==x))
    {
        int f=tr[x].f,ff=tr[f].f;
        if(ff==rt || (tr[ff].son[0]!=f && tr[ff].son[1]!=f))
        {
            if(tr[f].son[0]==x)rotate(x,1);
            else rotate(x,0);
        }
        else
        {
            if(tr[f].son[0]==x && tr[ff].son[0]==f)rotate(f,1),rotate(x,1);
            if(tr[f].son[1]==x && tr[ff].son[1]==f)rotate(f,0),rotate(x,0);
            if(tr[f].son[0]==x && tr[ff].son[1]==f)rotate(x,1),rotate(x,0);
            if(tr[f].son[1]==x && tr[ff].son[0]==f)rotate(x,0),rotate(x,1);
        }
    }
}
void access(int x)
{
    int y=0;
    while(x)
    {
        splay(x,0);
        tr[x].son[1]=y;
        if(y!=0)tr[y].f=x;
        y=x;x=tr[x].f;
    }
}
void makeroot(int x)
{
    access(x);splay(x,0);
    tr[x].lazy=1-tr[x].lazy;
}
void Link(int x,int y)
{
    makeroot(x);
    tr[x].f=y;
    access(x);
}
void Cut(int x,int y)
{
    makeroot(x);
    access(y);splay(y,0);
    tr[tr[y].son[0]].f=0;tr[y].son[0]=0;
    update(y);
}
int solve(int x,int y)
{
    makeroot(x);
    access(y);splay(y,0);
    update(y);
    return tr[y].sd;
}
int fa[51000];
int findfa(int x)
{
    if(fa[x]==x)return x;
    else
    {
        fa[x]=findfa(fa[x]);
        return fa[x];
    }
}
struct edge
{
    int x,y,w1,w2;
}e[110000];
bool cmp(edge a,edge b)
{
    if(a.w1>b.w1)return false;
    if(a.w1<b.w1)return true;
    return 0;
}
int main()
{
    int n,m,ans=999999999;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)fa[i]=i;
    for(int i=1;i<=m;i++)scanf("%d%d%d%d",&e[i].x,&e[i].y,&e[i].w1,&e[i].w2);
    sort(e+1,e+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
        int x=e[i].x,y=e[i].y;
        int fx=findfa(x),fy=findfa(y);
        if(fx==fy)
        {
            int wy=solve(x,y);
            if(a[wy]<=e[i].w2)continue;
            Cut(wy,e[wy-n].x);
            Cut(wy,e[wy-n].y);
        }
        else fa[fx]=fy;
        a[n+i]=e[i].w2;tr[n+i].sd=n+i;
        Link(x,n+i);Link(y,n+i);
        if(findfa(1)==findfa(n))ans=min(ans,e[i].w1+a[solve(1,n)]);
    }
    if(ans==999999999)printf("-1\n");
    else printf("%d\n",ans);
    return 0;
}