【NOI2014】魔法森林

Description

为了得到书法大家的真传，小 E 同学下定决心去拜访住在魔法森林中的隐士。魔法森林可以被看成一个包含 n 个节点 m 条边的无向图，节点标号为1,2,3, … , n，边标号为 1,2,3, … , m。初始时小 E 同学在 1 号节点，隐士则住在 n 号节点。小 E 需要通过这一片魔法森林，才能够拜访到隐士。

魔法森林中居住了一些妖怪。每当有人经过一条边的时候，这条边上的妖怪就会对其发起攻击。 幸运的是， 在 1 号节点住着两种守护精灵： A 型守护精灵与B 型守护精灵。小 E 可以借助它们的力量，达到自己的目的。

只要小 E 带上足够多的守护精灵， 妖怪们就不会发起攻击了。具体来说， 无向图中的每一条边 ei 包含两个权值 ai 与 bi 。 若身上携带的 A 型守护精灵个数不少于 ai ，且 B 型守护精灵个数不少于 bi ，这条边上的妖怪就不会对通过这条边的人发起攻击。当且仅当通过这片魔法森林的过程中没有任意一条边的妖怪向小 E 发起攻击，他才能成功找到隐士。

由于携带守护精灵是一件非常麻烦的事，小 E 想要知道， 要能够成功拜访到隐士，最少需要携带守护精灵的总个数。守护精灵的总个数为 A 型守护精灵的个数与 B 型守护精灵的个数之和。

Input

输入文件的第 1 行包含两个整数 n, m，表示无向图共有 n 个节点， m 条边。

接下来 m 行，第 i + 1 行包含 4 个正整数 Xi, Yi, ai, bi, 描述第 i 条无向边。其中Xi与Yi为该边两个端点的标号，ai与bi的含义如题所述。

注意数据中可能包含重边与自环。

Output

输出一行一个整数：如果小 E 可以成功拜访到隐士，输出小 E 最少需要携带的守护精灵的总个数；如果无论如何小 E 都无法拜访到隐士，输出“-1” （不含引号） 。

Sample Input

【样例输入 1】
4 5
1 2 19 1
2 3 8 12
2 4 12 15
1 3 17 8
3 4 1 17

【样例输入 2】
3 1
1 2 1 1

Sample Output

【样例输出 1】
32

【样例输出 2】
-1

Data Constraint

$n<=50000,m<=100000$

Solution

简化一下题意就是每条边有两个值（a和b），然后双关键字的最小生成树，答案要的是两个的和

可以想到使用LCT来解决这道题
先将边按照a从小到大排序，然后从前往后加边
加边时判断是否成环，如果是就找到环上的b的最大值的边，如果比当前边的b大，就切掉这条边，然后连上当前边
这就是LCT的基本操作了

边上的值如何用LCT维护？再多开一个点来存就行了

Code

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define N 301000
using namespace std;
int n,m,father[N],fa[N],p[N],t[N][2],rev[N],c[N],c1[N],b[N],d[N];
struct node{
    int x,y,a,b;
}a[N];
bool cnt(node x,node y){return x.a<y.a;}
int gf(int x){return father[x]==0?x:father[x]=gf(father[x]);}
int lr(int x){return x==t[fa[x]][1];}
void updata(int x)
{
    int mx=c[t[x][0]],m2=c1[t[x][0]];
    if(c[t[x][1]]>mx) mx=c[t[x][1]],m2=c1[t[x][1]];
    if(b[x]>mx) mx=b[x],m2=x;
    c[x]=mx;c1[x]=m2;
}
void down(int x)
{
    if(!rev[x]) return;
    swap(t[x][0],t[x][1]);
    rev[t[x][0]]^=1,rev[t[x][1]]^=1;
    rev[x]=0;
}
void rotate(int x)
{
    int y=fa[x],k=lr(x);
    t[y][k]=t[x][1-k];
    if(t[x][1-k]) fa[t[x][1-k]]=y;
    fa[x]=fa[y];
    if(fa[y]) t[fa[y]][lr(y)]=x;
    else p[x]=p[y],p[y]=0;
    t[x][1-k]=y;fa[y]=x;
    updata(y);updata(x);
}
void xc(int x,int y)
{
    do
    {
        d[++d[0]]=x;
        x=fa[x];
    } while(x!=y);
    for(;d[0];d[0]--) down(d[d[0]]);
}
void splay(int x,int y)
{
    xc(x,y);
    while(fa[x]!=y)
    {
        if(fa[fa[x]]!=y)
            if(lr(x)==lr(fa[x])) rotate(fa[x]);
            else rotate(x);
        rotate(x);
    }
}
void access(int x)
{
    int y=0;
    while(x!=0)
    {
        splay(x,0);
        fa[t[x][1]]=0,p[t[x][1]]=x;
        fa[y]=x,t[x][1]=y,p[y]=0;
        updata(x);
        y=x;x=p[x];
    }
}
void makeroot(int x)
{
    access(x);splay(x,0);rev[x]^=1;
}
void link(int x,int y)
{
    makeroot(x);p[x]=y;
}
void cut(int x,int y)
{
    makeroot(x);access(y);
    splay(y,0);
    t[y][0]=0;fa[x]=p[x]=0;
    updata(y);
}
int find(int x,int y)
{
    makeroot(x);access(y);
    splay(x,0);splay(y,x);
    return c1[t[y][0]];
}
int main()
{
    scanf("%d%d",&n,&m);
    fo(i,1,m) scanf("%d%d%d%d",&a[i].x,&a[i].y,&a[i].a,&a[i].b);
    sort(a+1,a+m+1,cnt);
    int ans=2147483647;
    fo(i,1,m)
    if(a[i].x!=a[i].y)
    {
        int x=gf(a[i].x),y=gf(a[i].y);
        if(x==y)
        {
            int k=find(a[i].x,a[i].y)-n;
            if(a[k].b>a[i].b)
            {
                cut(a[k].x,k+n),cut(k+n,a[k].y);
                b[i+n]=a[i].b;
                link(a[i].x,i+n),link(i+n,a[i].y);
            }   
        }
        else
        {
            father[x]=y;b[i+n]=a[i].b;
            link(a[i].x,i+n),link(i+n,a[i].y);
        }
        if(gf(1)==gf(n)) ans=min(ans,a[i].a+a[find(1,n)-n].b);
    }
    if(ans==2147483647) ans=-1;
    printf("%d",ans);
}