[Noi 2014]膜法森林

题目描述：

有 N 个节点 M 条边
每条边有两个参数 A B
我们开始时在 节点 1 要去节点 n
对于每条边 当我们携带的 参数 MA >= Ai MB >= Bi 我们才可以通过这条边
问最小的 MA + MB 是多少？

题目分析：

如果只有一个参数
那显然我们可以按照最小生成树的办法去做一颗生成树 而这颗树上最大的权值即为 答案
考虑两个参数的问题
首先将 A 升序排列
对于 B
我们可以动态的对B维护一颗最小生成树
这样每次枚举一条边，将这条边的 B 加入仅由 B 形成的最小生成树中
由于升序排序，那么生成树中的所有A <=当前枚举的边的Ai
那我们就可以对 Ai+Max(Bi)(生成树中的B) 取Min
而动态维护 生成树 用 LCT即可
总复杂度 O(NlogN)
当然本题还有一种 SPFA 的做法 SPFA复杂度玄学 很多OJ都过了 而且跑的比LCT还快
然而 在 UOJ上被 Hack 了 , 但仍有 95 分之多 相比起 LCT , 性价比高的一批

题目链接 ：

Luogu 2387
Bzoj 3669
COGS 1685
UOJ #3

Ac 代码：

#include <cstdio>
#include <iostream>
#include <algorithm>
#define il inline 
const int maxm=400000;
const int inf=1e9+7;
int si[maxm],ti[maxm],val[maxm];
int n,m,id;
struct node{
    int u,v,a,b;
}edge[maxm];
namespace LCT{
    int top,son[maxm][2],fa[maxm],max[maxm],stk[maxm],rev[maxm];
    il void pushup(int x) 
    {  
       max[x]=x;
       if(val[max[son[x][0]]]>val[max[x]]) max[x]=max[son[x][0]];
       if(val[max[son[x][1]]]>val[max[x]]) max[x]=max[son[x][1]];
    }  
    il void pushdown(int x)
    {
        if(rev[x])
        {
            rev[son[x][1]]^=1,rev[son[x][0]]^=1,rev[x]=0;
            std::swap(son[x][1],son[x][0]);
        }
    }
    il bool isroot(int x){return (son[fa[x]][1]!=x&&son[fa[x]][0]!=x);}
    void rotate(int x)
    {
        int fa1=fa[x],fa2=fa[fa1],l;
        if(son[fa1][0]==x) l=0;
        else l=1;
        int r=l^1;
        if(!isroot(fa1))
        {
         if(son[fa2][0]==fa1) son[fa2][0]=x;
         else son[fa2][1]=x;
        }
        fa[x]=fa2;fa[fa1]=x;fa[son[x][r]]=fa1;
        son[fa1][l]=son[x][r];son[x][r]=fa1;
        pushup(fa1);pushup(x);
    }
    void splay(int x)
    {
        top=1;stk[top]=x;
        for(int i=x;!isroot(i);i=fa[i]) stk[++top]=fa[i];
        for(int i=top;i;i--) pushdown(stk[i]);
        while(!isroot(x))
        {
            int y=fa[x],z=fa[y];
            if(!isroot(y))
            {
                if((son[y][0]==x)^(son[z][0]==y)) rotate(x);
                else rotate(y);
            }
            rotate(x);
        }
    }
    il void access(int x){for(int t=0;x;t=x,x=fa[x]) splay(x),son[x][1]=t,pushup(x);}//打通重路径 
    il void makeroot(int x){access(x),splay(x),rev[x]^=1;}//变为此Slpay的root 
    il int findroot(int x){access(x),splay(x);while(son[x][0])x=son[x][0];return x;}//寻找x所在树的根 
    il void split(int x,int y){makeroot(x);access(y);splay(y);}
    il void cut(int x,int y){split(x,y);if(son[y][0]==x) son[y][0]=0,fa[x]=0;}
    il void link(int x,int y){makeroot(x);fa[x]=y;}
    il bool ask(int x,int y)
    {
        if(x==y) return 1;
        return (findroot(x)==findroot(y));
    }
    il void addedge(int x,int y,int k)
    {
        if(findroot(x)^findroot(y))
        {
            id++;
            si[id]=x,ti[id]=y;
            val[id]=k,max[id]=id;
            link(x,id),link(y,id);
        }
        else
        {
            split(x,y);
            int v=max[y];
            if(val[v]<k) return;
            cut(si[v],v),cut(ti[v],v);
            id++;
            si[id]=x,ti[id]=y;
            val[id]=k,max[id]=id;
            link(x,id),link(y,id);
        }
    } 
    il int query(int x,int y)
    {
        if(findroot(x)^findroot(y)) return inf;
        split(x,y);
        return val[max[y]];
    }
};
il bool comp(node x,node y)
{
    return x.a!=y.a?x.a<y.a:x.b<y.b;
}
int main()
{
    //freopen("magicalforest.in","r",stdin);
    //freopen("magicalforest.out","w",stdout);
    scanf("%d%d",&n,&m);
    id=n;
    for(int i=1;i<=m;i++)
     scanf("%d%d%d%d",&edge[i].u,&edge[i].v,&edge[i].a,&edge[i].b);
    std::sort(edge+1,edge+m+1,comp);
    int ans=inf;
    for(int i=1;i<=m;i++)
    {
        LCT::addedge(edge[i].u,edge[i].v,edge[i].b);
        ans=std::min(ans,edge[i].a+LCT::query(1,n));
    }
    return printf("%d\n",ans==inf?-1:ans)*0;
}