从《NOI2014 魔法森林》看动态树(LCT)的简单应用

题目大意

给定一个$n$个结点，$m$条边的的无向图，每条边有两个权值$a_i,b_i$。
现在从1出发，要到达$n$，出发时带上任意多的$A,B$，每次只能沿着$a_i\leq A$且$b_i\leq B$的边走，问至少要带多少的$A,B$使得能从1到$n$。

Data Constraint
$n\leq50000,m\leq200000$

LCT

动态树，顾名思义就是支持动态维护的树形结构。
一般动态数支持$Link$连接一条边，$Cut$删除一条边，$Makeroot$将一个点转为树根。
算法的基本思想和树链剖分类似，每个点有一条实边（重边）与儿子相连，其余都是虚边（轻边），然后用多个Splay来分别维护每一条链（以深度为键值），记每一个点在Splay中的父亲结点为$Pre$，当前这个Splay的根节点的$Pre$指向的就是在原树中的另一条链（一定对应一条虚边）。时间复杂度是$O(log^2n)$，证明比较复杂，可以用势函数证明，这里省略。

下面简单介绍一下$LCT$的几种基本操作。

IsRoot

判断当前结点是否是Splay中的根。
根据$Pre$的定义，若当前结点$x$不是根，那么$Pre[x]$的儿子中必有一个点是$x$。反之，就说明$x$是根。

bool IsRoot( int x ) { return ( Son[Pre[x]][0] != x && Son[Pre[x]][1] != x ) ; }

Access

Access操作是$LCT$的核心操作，本质是取出当前点到当前根的这一段路径，将它们放到一个Splay中，是一个虚实切换的过程。
过程也很简单。

void Access( int x ) {
    int last = 0 ;
    while ( x ) {
        Splay(x) ;
        Son[x][1] = last ;
        last = x ;
        x = Pre[x] ;
    }
}

GetFa

求点$x$在原树中的父亲。
$x$的父亲必然在$x$到根的路径上，所以先$Access(x)$，然后将$x$旋到Splay的根，那么$x$的父亲就是$x$左子树中深度最大的那一个点。

int GetFa( int x ) {
    Access(x) ;
    Splay(x) ;
    x = Son[x][0] ;
    while ( Son[x][1] ) x = Son[x][1] ;
    return x ;
}

MakeRoot

$MakeRoot$就是常说的换根操作。$MakeRoot(x)$将$x$旋转到它所在树的根。
如何实现？观察到每次$x$换根的时候，会且仅会将$x$到根路径上的点的关系反转（即儿子、父亲关系反转），对其余的点都没有影响。
所以只要$Access(x)$然后$Splay(x)$，在$x$上打翻转标记即可。

void MakeRoot( int x ) {
    Access(x) ;
    Splay(x) ;
    Rev[x] ^= 1 ;
}

Query

$Query(u,v)$查询树上$u\rightarrow v$路径的信息。
因为$Access$是取点到根的路径。所以先$MakeRoot(u)$然后$Access(v)$即可。

void Query( int u , int v ) {
    MakeRoot(u) ;
    Access(v) ;
    Splay(v) ;
}

Link

LCT的基础操作，将两个点连起来。对于$Link(u,v)$不妨设我们要将$v$连到$u$的下面。那么显然是先将$v$，旋转到它所在的树的根($MakeRoot(v)$)，然后将这一整颗树连向$u$.

void Link( int u , int v ) {
    MakeRoot(v) ;
    Pre[v] = u ;
}

Cut

LCT的基础操作，将两个点之间的边断开。对于$Cut(u,v)$，先$MakeRoot(u)$，然后$Splay(v)$，再$Splay(v)$那么此时$v$的左儿子必然是$u$，直接断开即可。

void Cut( int u , int v ) {
    MakeRoot(u) ;
    Access(v) ;
    Splay(v) ;
    Pre[u] = Son[v][0] = 0 ;
}

题解

回到本题。考虑将边按照$a_i$排序，依次加入每一条边，并维护$b_i$的最大值。
用并查集维护连通性，若出现环，就将环边上$b_i$最大的边删除。这些操作都可以用LCT实现。

时间复杂度：$O(nlog^n)$

SRC

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std ;

#define N 200000 + 10
struct Edge {
    int u , v , a , b ;
} E[N] ;

bool Rev[N] ;
int fa[N] , D[N] ;
int Son[N][2] , Pre[N] , Maxv[N] , V[N] ;
int n , m , ans = 0x7FFFFFFF ;

bool cmp( Edge x , Edge y ) { return x.a < y.a ; }

int Get( int x ) { return fa[x] == x ? x : fa[x] = Get(fa[x]) ; }

bool IsRoot( int x ) { return ( Son[Pre[x]][0] != x && Son[Pre[x]][1] != x ) ; }

void Push( int x ) {
    if ( !Rev[x] ) return ;
    swap( Son[x][0] , Son[x][1] ) ;
    Rev[Son[x][0]] ^= 1 ;
    Rev[Son[x][1]] ^= 1 ;
    Rev[x] = 0 ;
}

void Update( int x ) {
    int ls = Son[x][0] ;
    int rs = Son[x][1] ;
    Maxv[x] = x ;
    if ( V[Maxv[ls]] > V[Maxv[x]] ) Maxv[x] = Maxv[ls] ;
    if ( V[Maxv[rs]] > V[Maxv[x]] ) Maxv[x] = Maxv[rs] ;
}

void Rotate( int x ) {
    int F = Pre[x] , G = Pre[F] ;
    int Side = ( Son[F][1] == x ) ;
    if ( !IsRoot(F) ) Son[G][Son[G][1] == F] = x ;
    Pre[F] = x , Pre[x] = G ;
    Son[F][Side] = Son[x][!Side] ;
    Pre[Son[x][!Side]] = F ;
    Son[x][!Side] = F ;
    Update(F) ;
    Update(x) ;
}

void Splay( int x ) {
    D[D[0] = 1] = x ;
    for (int p = x ; !IsRoot(p) ; p = Pre[p] ) D[++D[0]] = Pre[p] ;
    for (int i = D[0] ; i ; i -- ) Push(D[i]) ;
    while ( !IsRoot(x) ) {
        int y = Pre[x] , z = Pre[y] ;
        if ( !IsRoot(y) ) {
            if ( (Son[y][0] == x) ^ (Son[z][0] == y) ) Rotate(x) ;
            else Rotate(y) ;
        }
        Rotate(x) ;
    }
    Update(x) ;
}

void Access( int x ) {
    int last = 0 ;
    while ( x ) {
        Splay(x) ;
        Son[x][1] = last ;
        last = x ;
        x = Pre[x] ;
    }
}

void MakeRoot( int x ) {
    Access(x) ;
    Splay(x) ;
    Rev[x] ^= 1 ;
}

void Query( int u , int v ) {
    MakeRoot(u) ;
    Access(v) ;
    Splay(v) ;
}

void Link( int u , int v ) {
    MakeRoot(u) ;
    Pre[u] = v ;
}

void Cut( int u , int v ) {
    Query( u , v ) ;
    Pre[u] = Son[v][0] = 0 ;
}

int main() {
    scanf( "%d%d" , &n , &m ) ;
    for (int i = 1 ; i <= n ; i ++ ) fa[i] = i ;
    for (int i = 1 ; i <= m ; i ++ ) scanf( "%d%d%d%d" , &E[i].u , &E[i].v , &E[i].a , &E[i].b ) ;
    sort( E + 1 , E + m + 1 , cmp ) ;
    for (int i = 1 ; i <= m ; i ++ ) {
        int u = E[i].u ;
        int v = E[i].v ;
        int fx = Get(u) , fy = Get(v) ;
        V[i+n] = E[i].b ;
        if ( fx != fy ) {
            fa[fx] = fy ;
            Link( i + n , u ) ;
            Link( i + n , v ) ;
        } else {
            Query( u , v ) ;
            int now = Maxv[v] ;
            if ( V[now] <= V[i+n] ) continue ;
            Cut( now , E[now-n].u ) ;
            Cut( now , E[now-n].v ) ;
            Link( i + n , u ) ;
            Link( i + n , v ) ;
        }
        if ( Get(1) == Get(n) ) {
            Query( 1 , n ) ;
            ans = min( ans , E[i].a + V[Maxv[n]] ) ;
        }
    }
    if ( ans == 0x7FFFFFFF ) ans = -1 ;
    printf( "%d\n" , ans ) ;
    return 0 ;
}

以上.