bzoj3669: [Noi2014]魔法森林

地址：

题目：

3669: [Noi2014]魔法森林

Time Limit: 30 Sec  Memory Limit: 512 MB
Submit: 2955  Solved: 1851
[Submit][Status][Discuss]

Description

为了得到书法大家的真传，小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型守护精灵的个数之和。

Input

第1行包含两个整数N,M，表示无向图共有N个节点，M条边。 接下来M行，第行包含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
【样例说明1】
如果小E走路径1→2→4，需要携带19+15=34个守护精灵；
如果小E走路径1→3→4，需要携带17+17=34个守护精灵；
如果小E走路径1→2→3→4，需要携带19+17=36个守护精灵；
如果小E走路径1→3→2→4，需要携带17+15=32个守护精灵。
综上所述，小E最少需要携带32个守护精灵。



【输出样例2】


-1
【样例说明2】
小E无法从1号节点到达3号节点，故输出-1。

HINT

 

2<=n<=50,000

0<=m<=100,000

1<=ai ,bi<=50,000

 

思路：

　　二维mst？

　　考虑先把边按第一关键字为ai，第二关键字为bi排序，然后依次加边。

　　如果成环了，就删掉环上bi最大的边。

　

/**************************************************************
    Problem: 3669
    User: weeping
    Language: C++
    Result: Accepted
    Time:6500 ms
    Memory:48200 kb
****************************************************************/
 
#include <bits/stdc++.h>
 
using namespace std;
 
struct node
{
    int u,v,a,b;
    node(){}
    node(int x,int y,int z,int w){u=x,v=y,a=z,b=w;}
    bool operator < (const node &ta) const
    {
        return a < ta.a || ( a == ta.a && b < ta.b);
    }
}eg[1000005];
 
struct Link_Cut_Tree
{
    static const int MAXN = 1000000 + 7;
 
    int ch[MAXN][2], fa[MAXN], rev[MAXN], v[MAXN], mx[MAXN], id[MAXN];
    int sk[MAXN];
 
    bool isroot(int x)
    {
        return ch[fa[x]][0] != x && ch[fa[x]][1] != x;
    }
 
    void reverse(int x)
    {
        rev[x] ^= 1, swap(ch[x][0],ch[x][1]);
    }
 
    void update(int x)
    {
        int lc = ch[x][0],rc = ch[x][1];
        mx[x] = v[x], id[x] = x;
        if(lc && mx[lc] > mx[x])
            mx[x] = mx[lc], id[x] = id[lc];
        if(rc && mx[rc] > mx[x])
            mx[x] = mx[rc], id[x] = id[rc];
    }
 
    void push_down(int x)
    {
        if(!rev[x]) return ;
        if(ch[x][0]) reverse(ch[x][0]);
        if(ch[x][1]) reverse(ch[x][1]);
        rev[x]=0;
    }
 
    void rotate(int x)
    {
        int f = fa[x], gf = fa[f];
        int t1 = ( x != ch[f][0]), t2 = ( f != ch[gf][0]), tmp = ch[x][1^t1];
        if(!isroot(f)) ch[gf][0^t2] = x;
        fa[tmp] = f, fa[x] = gf, ch[x][1^t1] = f, fa[f] = x, ch[f][0^t1] = tmp;
        update(f);
    }
 
    void splay(int x)
    {
        int top = 0;
        sk[++top] = x;
        for(int i = x; !isroot(i); i = fa[i])   sk[++top] = fa[i];
        while(top)  push_down(sk[top--]);
        for(int f = fa[x], gf = fa[f]; !isroot(x); rotate(x), f = fa[x],gf = fa[f])
        if(!isroot(f))
            rotate((x==ch[f][0]) ^ (f==ch[gf][0]) ? x : f);
        update(x);
    }
 
    void access(int x)
    {
        for(int p = 0; x; p = x, x = fa[x])
            splay(x), ch[x][1] = p, update(x);
    }
 
    void makeroot(int x)
    {
        access(x), splay(x), reverse(x);
    }
 
    int findroot(int x)
    {
        access(x), splay(x);
        while(ch[x][0]) x = ch[x][0];
        return x;
    }
    void link(int x,int y)
    {
        makeroot(x), fa[x] = y;
    }
 
    void cut(int x,int y)
    {
        makeroot(x), access(y), splay(y);
        if(ch[y][0] == x)   ch[y][0] = fa[x] = 0;
        update(y);
    }
 
    void go(int n,int m)
    {
        int ans=1e9;
        sort(eg+1,eg+1+m);
        for(int i=1;i<=m;i++)
        {
            int tu=eg[i].u,tv=eg[i].v,bi=eg[i].b,p=i+n;
            v[p]=mx[p]=bi,id[p]=p;
            if(tu==tv)  continue;
            if(findroot(tu)!=findroot(tv))
                link(tu,p),link(p,tv);
            else
            {
                makeroot(tu),access(tv),splay(tv);
                if(mx[tv] > bi)
                {
                    int q=id[tv]-n;
                    cut(eg[q].u,q+n),cut(eg[q].v,q+n);
                    link(tu,p),link(p,tv);
                }
            }
            if(findroot(1)==findroot(n))
            {
                makeroot(1),access(n),splay(n);
                ans=min(ans,eg[i].a+mx[n]);
            }
        }
        if(ans==(int)1e9)
            printf("-1\n");
        else
            printf("%d\n",ans);
    }
}lct;
 
int main(void)
{
    //freopen("in.acm","r",stdin);
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) lct.v[i]=-1;
    for(int i=1,x,y,a,b;i<=m;i++)
        scanf("%d%d%d%d",&x,&y,&a,&b),eg[i] = node(x,y,a,b);
    lct.go(n,m);
    return 0;
}