BZOJ3669：[NOI2014]魔法森林——题解

http://www.lydsy.com/JudgeOnline/problem.php?id=3669

https://www.luogu.org/problemnew/show/P2387

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

（参考洛谷前好几篇题解）

刚开始做的时候是一筹莫展的，但思考一下实际上我们就是找一棵生成树，使得a+b最小。

只是很可惜的是，我们并不能找所谓最小生成树。

但是考虑，我们完全可以固定a的值，添加的边权即为b，这样答案就是a+maxb了。

所以先对边按a排序，然后按照kruskal算法添加边(u,v,b)：

如果u和v之间不连通，那么我们就加这条边。

如果u和v之间连通，那么找到u到v之间的路上b最大的，把他cut掉，然后再加。

每次加边之后检查1和n是否连通，如果连通更新ans=min(ans，a+1到n之间路上b最大的)

显然这么做可以保证对于必须添加的边，我们的b是最小的，那么答案的正确性就是显然的。

关键问题是用什么数据结构维护。

考虑连成的图始终是树，且需要支持连边和删边的操作，且需要（动态的）知道一条路径上最大b，我们选用LCT。

那么边权对于LCT不好维护，我们把边权开成点，即X->Y变成X->Z->Y，其中Z的点权为b，这样就可以维护了。

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cctype>
#include<cstdio>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
const int INF=1e9;
const int N=2e5+10;
const int M=1e5+10;
struct node{
    int u,v,a,b;
}e[M];
int n,m,r,k[N],fa[N],tr[N][2],rev[N],val[N],q[N],num[N];
inline bool cmp(node a,node b){
    return a.a<b.a||(a.a==b.a&&a.b<b.b);
}
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 get(int x){
    return tr[fa[x]][1]==x;
}
inline bool isroot(int x){
    if(!fa[x])return 1;
    return tr[fa[x]][0]!=x&&tr[fa[x]][1]!=x;
}
inline void upt(int x){
    int id=val[tr[x][0]],maxb=e[id].b;
    if(maxb<e[val[tr[x][1]]].b)id=val[tr[x][1]],maxb=e[id].b;
    if(maxb<e[num[x]].b)id=num[x],maxb=e[id].b;
    val[x]=id;
}
inline void pushrev(int x){
    if(!rev[x])return;
    swap(tr[x][0],tr[x][1]);
    if(tr[x][0])rev[tr[x][0]]^=1;
    if(tr[x][1])rev[tr[x][1]]^=1;
    rev[x]=0;
}
inline void rotate(int x){
    int y=fa[x],z=fa[y],b=tr[y][0]==x?tr[x][1]:tr[x][0];
    if(z&&!isroot(y))(tr[z][0]==y?tr[z][0]:tr[z][1])=x;
    fa[x]=z;fa[y]=x;b?fa[b]=y:0;
    if(tr[y][0]==x)tr[x][1]=y,tr[y][0]=b;
    else tr[x][0]=y,tr[y][1]=b;
    upt(y);upt(x);
}
inline void splay(int x){
    q[r=0]=x;
    for(int y=x;!isroot(y);y=fa[y])q[++r]=fa[y];
    for(int i=r;i>=0;i--)pushrev(q[i]);
    while(!isroot(x)){
    if(!isroot(fa[x]))
        rotate((get(x)==get(fa[x])?fa[x]:x));
    rotate(x);
    }
    upt(x);
}
inline void access(int x){
    for(int y=0;x;y=x,x=fa[x]){
    splay(x);tr[x][1]=y;
    if(y)fa[y]=x;
    }
}
inline int findroot(int x){
    access(x);splay(x);
    while(pushrev(x),tr[x][0])x=tr[x][0];
    splay(x);
    return x;
}
inline void makeroot(int x){
    access(x);splay(x);
    rev[x]^=1;
}
inline void link(int x,int y){
    makeroot(x);fa[x]=y;
}
inline void cut(int x,int y){
    makeroot(x);access(y);splay(y);
    tr[y][0]=0;fa[x]=0;
}
inline int query(int u,int v){
    makeroot(u);access(v);splay(v);
    return val[v];
}
int main(){
    n=read();m=read();
    for(int i=1;i<=m;i++)
    e[i].u=read(),e[i].v=read(),e[i].a=read(),e[i].b=read();
    sort(e+1,e+m+1,cmp);
    int ans=INF;
    for(int i=1;i<=m;i++){
    int u=e[i].u,v=e[i].v,a=e[i].a,b=e[i].b;
    if(findroot(u)!=findroot(v)){
        num[i+n]=val[i+n]=i;
        link(u,i+n);link(v,i+n);
    }else{
        int t=query(u,v);
        if(e[t].b>b){
        cut(e[t].u,t+n);cut(e[t].v,t+n);
        num[i+n]=val[i+n]=i;
        link(u,i+n);link(v,i+n);
        }
    }
    if(findroot(1)==findroot(n))
        ans=min(ans,e[query(1,n)].b+a);
    }
    printf("%d
",ans==INF?-1:ans);
    return 0;
}

+++++++++++++++++++++++++++++++++++++++++++

 +本文作者：luyouqi233。 　　　　　　　　　　　　　　+

 +欢迎访问我的博客：http://www.cnblogs.com/luyouqi233/+

+++++++++++++++++++++++++++++++++++++++++++