[BZOJ 3669][NOI 2014]魔法森林(Link-Cut Tree)

题目链接：http://www.lydsy.com:808/JudgeOnline/problem.php?id=3669

记得四个月之前的NOI同步赛，我还只会玩脚丫子。。。。

记得我当时看到这个题整个人就吓傻了，完全不知道怎么做，然后NOI同步赛就这样爆零了。。。

如今我学了LCT这个神器，再看这个题，感觉不再那么难了。

其实这个题的标准解法是SPFA，改得完全认不出来的SPFA。

orz太神了，完全没见识过这么神犇的SPFA，NOIP 2014考了SPFA，NOI 2014也考了SPFA，原来SPFA也能玩出这么多花样。

我只会用LCT暴力这题，我会暴力我自豪。然后我orz了hzwer的本题lct版本代码和bin神的lct模板，自己yy乱弄了下过了这个题。

下面是我的思路，如有错误请不吝指教。

first of all，我们要构造下这题的LCT，在这题中，图有n个点m条边，于是lct里，下标在[1,n]的结点都是图中的点，下标在(n,m+n]中的结点都是图中的边，只有边对应的结点有权值，这个权值就是对应的边的b值。

然后我们用类似kruscal的方法，将每个边按照关键字a值升序排序，然后搞个并查集，维护图的连通性。

接着，我们像搞最小生成树一样，按a值从小到大不断地加边，维护并查集，加一条边时，要同时在LCT里连接这条边的两个点u和v，具体做法是先连接u和边对应的结点，再把边对应的结点和v相连。

在这个过程中，如果出现遍历到一条边u-v时，u-v本身是联通的，那么我们不加此边，但是要看LCT中u到v路径上的最大权值是不是大于这条边的b值，若是的话，则需要断掉u到v路径上最大权值的那条边的连接，加入这条边。

最后，答案就是min(a+LCT中起点对应结点到终点对应结点路径上的最大权值之和)。

PS：忍不住吐槽下，我第一次WA掉居然是因为splay操作最后忘了上传标记，orzorz。。。。。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

#define MAXN 150050
#define MAXE 100005
#define INF 0x3f3f3f3f

using namespace std;

struct edge
{
    int u,v,a,b;
}edges[MAXE];

int n,m,nCount=0,ans=INF;
int f[MAXN];
int ch[MAXN][2],fa[MAXN];
int val[MAXN],maxv[MAXN]; //该点值的标记、该点对应区间的最大值对应结点的下标
bool rev[MAXN]; //翻转标记
bool isRoot[MAXN]; //根节点标记

int findSet(int x)
{
    if(f[x]==x) return x;
    return f[x]=findSet(f[x]);
}

bool operator<(edge a,edge b)
{
    return a.a<b.a;
}
//Start Of Splay
void updateRev(int r) //更新结点r的rev标记
{
    if(!r) return;
    swap(ch[r][0],ch[r][1]);
    rev[r]^=1;
}

void pushdown(int r) //更新结点r的rev标记
{
    if(rev[r])
    {
        updateRev(ch[r][0]);
        updateRev(ch[r][1]);
        rev[r]=0;
    }
}

void pushup(int r) //更新maxv域
{
    int lc=ch[r][0],rc=ch[r][1];
    maxv[r]=r;
    if(val[maxv[lc]]>val[maxv[r]]) maxv[r]=maxv[lc];
    if(val[maxv[rc]]>val[maxv[r]]) maxv[r]=maxv[rc];
}

void rotate(int x) //将x旋到上面一层去
{
    int y=fa[x],kind=ch[y][1]==x;
    ch[y][kind]=ch[x][!kind];
    fa[ch[y][kind]]=y;
    fa[x]=fa[y];
    fa[y]=x;
    ch[x][!kind]=y;
    if(isRoot[y]) //y是根节点，则需要更新根节点标记
    {
        isRoot[y]=false;
        isRoot[x]=true;
    }
    else
        ch[fa[x]][ch[fa[x]][1]==y]=x;
    pushup(y);
}

void P(int r) //维护r和它的祖先们
{
    if(!isRoot[r]) P(fa[r]);
    pushdown(r);
}

void splay(int r) //将r旋到根节点上去
{
    P(r);
    while(!isRoot[r])
    {
        int f=fa[r],ff=fa[f]; //父结点、祖父结点
        if(isRoot[f])
            rotate(r);
        else if((ch[ff][1]==f)==(ch[f][1]==r)) //r、r的父亲、r的祖父三点共线
            rotate(f),rotate(r);
        else
            rotate(r),rotate(r);
    }
    pushup(r);
}
//End Of Splay
//Start Of Link-Cut Tree
int access(int x) //打通x到根节点的偏爱路径
{
    int y=0;
    do
    {
        splay(x);
        isRoot[ch[x][1]]=true;
        isRoot[ch[x][1]=y]=false;
        pushup(x);
        x=fa[y=x];
    }while(x);
    return y;
}

void memroot(int r) //使r成为所在树的根
{
    access(r);
    splay(r);
    updateRev(r);
}

void link(int u,int v) //link操作
{
    memroot(u);
    fa[u]=v;
}

void cut(int u,int v) //cut操作
{
    memroot(u);
    access(v);
    splay(v);
    fa[ch[v][0]]=fa[v];
    fa[v]=0;
    isRoot[ch[v][0]]=true;
    ch[v][0]=0;
    pushup(v);
}
//End Of Link-Cut Tree

int query(int x,int y) //求点x到y之间路径上的最大值
{
    memroot(x);
    access(y);
    splay(y);
    return maxv[y];
}

void solve(int k) //如果边k链接的两边的点u和v本身联通，而且u到v路径上的最大的b值比边k的b值大，则用边k去代替点u到v的路径
{
    int u=edges[k].u,v=edges[k].v,w=edges[k].b;
    int t=query(u,v);
    if(w<val[t])
    {
        cut(edges[t-n].u,t);
        cut(edges[t-n].v,t);
        link(u,k+n);
        link(v,k+n);
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n+m;i++) isRoot[i]=true;
    for(int i=1;i<=n;i++) f[i]=i;
    for(int i=1;i<=m;i++)
        scanf("%d%d%d%d",&edges[i].u,&edges[i].v,&edges[i].a,&edges[i].b);
    sort(edges+1,edges+m+1);
    for(int i=1;i<=m;i++)
    {
        val[n+i]=edges[i].b;
        maxv[n+i]=n+i;
    }
    for(int i=1;i<=m;i++) //进行类似于kruscal的操作，一边维护连通性，一边往lct里面加边
    {
        int u=edges[i].u,v=edges[i].v,w=edges[i].b;
        int rootu=findSet(u),rootv=findSet(v);
        if(rootu!=rootv)
        {
            f[rootu]=rootv;
            link(u,n+i);
            link(v,n+i);
        }
        else solve(i);
        if(findSet(1)==findSet(n)) //起点到终点之间已经联通了
            ans=min(ans,val[query(1,n)]+edges[i].a);
    }
    if(ans!=INF) printf("%d\n",ans);
    else printf("-1");
    return 0;
}