BZOJ 3669 . JZOJ 3754. 【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

Solution

• 先按边的 a 值排序，从小到大依次加入图中。

• 若边连接的是两个不同的连通块，则直接连通。

• 否则就从生成树中找到最大的那条边，删掉，改为连当前的边。

• 这个操作用 LCT 维护即可。

• 若连接后 1 和 n 是联通的，就更新一下答案即可。

• 注意由于权值在边上，所以要新开一个点作为权值，再连向两个端点。

• 时间复杂度 O(M log (N+M)) 。

Code

#include<cstdio>
#include<algorithm>
#include<cctype>
using namespace std;
const int N=2e5+3;
struct data
{
    int x,y,a,b;
}a[N];
int ans=N,top;
int fa[N],s[N][2],st[N],mx[N],num[N];
bool rev[N];
inline int read()
{
    int X=0,w=0; char ch=0;
    while(!isdigit(ch)) {w|=ch=='-';ch=getchar();}
    while(isdigit(ch)) X=(X<<3)+(X<<1)+(ch^48),ch=getchar();
    return w?-X:X;
}
inline bool cmp(data x,data y)
{
    return x.a<y.a;
}
inline int max(int x,int y)
{
    return x>y?x:y;
}
inline bool pd(int x)
{
    return x==s[fa[x]][1];
}
inline bool isroot(int x)
{
    return s[fa[x]][0]^x && s[fa[x]][1]^x;
}
inline void modify(int x)
{
    if(x) swap(s[x][0],s[x][1]),rev[x]^=1;
}
inline void update(int x)
{
    num[x]=mx[num[s[x][0]]]>mx[num[s[x][1]]]?num[s[x][0]]:num[s[x][1]];
    if(mx[x]>mx[num[x]]) num[x]=x;
}
inline void down(int x)
{
    if(rev[x])
    {
        modify(s[x][0]),modify(s[x][1]);
        rev[x]=false;
    }
}
inline void rotate(int x)
{
    int y=fa[x],w=pd(x);
    if(s[y][w]=s[x][w^1]) fa[s[x][w^1]]=y;
    if((fa[x]=fa[y]) && !isroot(y)) s[fa[y]][pd(y)]=x;
    s[fa[y]=x][w^1]=y;
    update(y);
}
inline void splay(int x)
{
    for(int y=st[top=1]=x;!isroot(y);y=fa[y]) st[++top]=fa[y];
    while(top) down(st[top--]);
    for(int y;!isroot(x);rotate(x))
        if(!isroot(y=fa[x])) rotate(pd(x)==pd(y)?y:x);
    update(x);
}
inline void access(int x)
{
    for(int y=0;x;x=fa[y=x]) splay(x),s[x][1]=y,update(x);
}
inline void mkroot(int x)
{
    access(x),splay(x),modify(x);
}
inline void link(int x,int y)
{
    mkroot(x),fa[x]=y;
}
inline void cut(int x,int y)
{
    mkroot(x),access(y),splay(y);
    s[y][0]=fa[x]=0;
}
inline int get(int x)
{
    access(x),splay(x);
    int y=x;while(s[y][0]) y=s[y][0];
    return y;
}
int main()
{
    int n=read(),m=read();
    for(int i=1;i<=m;i++) a[i].x=read(),a[i].y=read(),a[i].a=read(),a[i].b=read();
    sort(a+1,a+1+m,cmp);
    for(int i=1;i<=m;i++)
    {
        int x=a[i].x,y=a[i].y,z=i+n;
        mx[num[z]=z]=a[i].b;
        if(get(x)^get(y)) link(x,z),link(y,z); else
        {
            mkroot(x),access(y),splay(y);
            if(a[i].b<mx[num[y]])
            {
                int p=num[y];
                cut(p,a[p-n].x),cut(p,a[p-n].y);
                link(z,x),link(z,y);
            }
        }
        if(get(1)==get(n))
        {
            mkroot(n),access(1),splay(1);
            if(a[i].a+mx[num[1]]<ans) ans=a[i].a+mx[num[1]];
        }
    }
    printf("%d",ans==N?-1:ans);
    return 0;
}