【BZOJ3669】魔法森林(LCT动态维护最小生成树)

题目连接

题目描述

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

题意简述: 给你一张无向带权图，每条边有两种权值。求出一条从 1到n 的路径使得路径上的两种权值的最大值之和最小，并输出这个最小值

题解

直接写LCT吧，SPFA的在另一篇blog里。

和SPFA的方法类似，把 a 从小到大排序，并暴力枚举 a 。
然后是 LCT 维护 b 的最小生成树。维护的话，对于新来的一条边(u,v)，若u，v未联通，则连上即可，不然就查询路径上最大边权的边，若其边权大于(u，v)的边权就把他换掉。
原理和SPFA的方法的原理也类似。

需要注意的是边权的处理。LCT不好处理边权，要新建一个点表示边，比如说有边(u,v)，那么就新建一个点 p ，点权为边的边权，让后u向p，p向v 分别连边。
但是有一个坑点(至少坑了我)，不要以为把新建点Splay到根后，左右儿子就是原来的u和v了(至少我这么写就RE了)，要新搞一个id记录该点是哪条边。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cmath>
using namespace std;
#define ls son[0]
#define rs son[1]
#define get_son(a) (a->fa->rs==a)
#define __ NULL
#define get_mx(a) (a==__? 0:a->mx->x)
const int N=5e4+10;
const int M=4e5+10;
struct node{
    node* fa;node* son[2];
    bool rev;bool is_root;
    int x;node* mx;int id;
    inline void clear(){fa=ls=rs=__;is_root=1;rev=0;x=0;mx=this;id=0;}
    node(){fa=ls=rs=__;is_root=1;rev=0;x=0;mx=this;id=0;}
}*tr[M];
inline int read()
{
    int x=0;char ch=getchar();int t=1;
    for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') t=-1;
    for(;ch>='0'&&ch<='9';ch=getchar()) x=(x<<1)+(x<<3)+ch-48;
    return x*t;
}
const int INF=1e9;
node pool[M];
node* st[M];
inline void updata(node* p)
{
    if(p==__) return;
    register int a=p->x,b=get_mx(p->ls),c=get_mx(p->rs);p->mx=p;
    if(b>a&&p->ls!=__) p->mx=p->ls->mx;
    if(c>a&&c>=b&&p->rs!=__) p->mx=p->rs->mx;
}
inline void push_down(node* p)
{
    if(p==__||p->rev==0) return;
    p->rev=0;
    if(p->ls!=__) p->ls->rev^=1;
    if(p->rs!=__) p->rs->rev^=1;
    swap(p->ls,p->rs);
}
inline void push(node* p)
{
    int top;st[top=1]=p;
    while(!p->is_root) st[++top]=(p=p->fa);
    while(top) push_down(st[top--]);
}
inline void rotate(node* p)
{
    if(p->is_root) return;
    register node* q=p->fa;register node* gp=q->fa;
    register int k=get_son(p);
    q->son[k]=p->son[k^1];
    if(p->son[k^1]!=__) p->son[k^1]->fa=q;p->fa=gp;
    if(q->is_root) p->is_root=1,q->is_root=0;
    else if(gp!=__) gp->son[get_son(q)]=p;
    q->fa=p;p->son[k^1]=q;updata(q);updata(p);
    return;
}
inline void Splay(node* p)
{
    push(p);
    for(;!p->is_root;rotate(p)){
        if(p->fa->is_root) continue;
        if(get_son(p)==get_son(p->fa)) rotate(p->fa);
        else rotate(p);
    }
    updata(p);
}
inline void access(node* p)
{
    for(register node* pre=__;p!=__;pre=p,p=p->fa)
    {
        Splay(p);if(p->rs!=__) p->rs->is_root=1;p->rs=pre;
        if(pre!=__) pre->is_root=0;updata(p);
    }
}
inline void m_root(node* p) {access(p);Splay(p);p->rev^=1;}
inline void split(node* p,node* q) {m_root(p);access(q);Splay(q);}//分离路径
inline void Link(node* p,node* q) {m_root(p);p->fa=q;}
inline void Cut(node* p,node* q) {split(p,q);if(q->ls==p) p->fa=q->ls=__,p->is_root=1,updata(q);}
inline node* find(node* p) {for(access(p),Splay(p);p->ls!=__;p=p->ls);return p;}
struct edge{
    int from;int to;int va,vb;
    inline bool operator <(edge p)const{
        return va<p.va;
    }
}ed[102000];
int n,m;
int head[N];
int cnt=0;
inline void add(int x,int y,int a,int b){ed[++cnt]=(edge){x,y,a,b};}
int cn;
inline void Add(node* p,node* q,int x)
{
    tr[cn]=&pool[cn];tr[cn]->clear();tr[cn]->x=x;tr[cn]->id=cn-n;
    Link(tr[cn],p);Link(tr[cn],q);
}
inline node* Query(node* p,node* q){split(p,q);return q->mx;}
inline void change(node* p,node* q,int b)
{
    register node* pos=Query(p,q);
    if(pos->x>b){
        edge E=ed[pos->id];//记住边的序号
        Cut(pos,tr[E.from]);Cut(pos,tr[E.to]);
        pos->clear();
        updata(p);updata(q);
        Add(p,q,b);
    }
}
int main()
{
    n=read();m=read();register int x,y,a,b;
    for(register int i=1;i<=m;i++){
        x=read();y=read();a=read();b=read();
        if(x==y) {m--;i--;continue;}
        add(x,y,a,b);
    }
    for(register int i=1;i<=n;i++){tr[i]=&pool[i];tr[i]->clear();}
    int ans=INF;
    cn=n;
    sort(ed+1,ed+1+m);
    for(register int h=1;h<=m;h++){
        a=ed[h].va;b=ed[h].vb;cn++;
        if(find(tr[ed[h].from])!=find(tr[ed[h].to])) Add(tr[ed[h].from],tr[ed[h].to],b);
        else change(tr[ed[h].from],tr[ed[h].to],b);
        if(find(tr[1])==find(tr[n]))
            ans=min(ans,a+(Query(tr[1],tr[n])->x));
    }
    if(ans==INF) puts("-1");
    else printf("%d\n",ans);
}