长跑

n个点，m个事件
输入ｎ个点的权值
输入ｍ个事件
三个整数描述事件 P　Ａ　Ｂ
ｐ＝＝１　Ａ　到Ｂ连一条双向边
ｐ＝＝２　Ａ　点的权值改为Ｂ
ｐ＝＝３　从Ａ走到Ｂ，走过某条路，那条路便不可再次反向通过（可以正向），每次第一次到达某个点，获得该点权值。

对于100%的数据， m<=5n，点权不超过10000。

具体每组数据的规模如下

编号 n 编号 n

1 10 6 50000

2 100 7 100000

3 1000 8 100000

4 10000 9 150000

5 2×10000 10 150000

可以用ＬＣＴ做，不过有更机智的方法。
首先按添边顺序构建一颗树（以输入顺序为权的ＭＳＴ）
构出DFS序。在其基础上构建线段树。对于每个点，维护其到根节点的权值和。
离线开始做，添边时若构出环则用并查集，以LCA(u,v)为代表点，u到v上的点染成LCA现在的颜色，往LCA上跳时同时维护线段树。即整个子树区间减去当前跳到的点的权值，然后在lca位置处对其子树加上整个环的权值和 。（因为查询只涉及到线段树单点查询，所以可以这么做）
询问就很容易了，就不多说了。

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std ;

typedef long long ll ;

#define N 150010 * 5
#define M N * 5  

int n , m , i , j , k , g[N] , T ;

struct EDGE {
    int y , l ;
}f[N*2] ;

int ds[N] ; // Communicatd Judging 

ll mark[N] , sum[N] ;

void Effect( int p , int l , int r ) {
    sum[p] +=  mark[p] * ( r-l+1 )  ;
    if( l!=r ) mark[p*2] += mark[p] , mark[p*2+1] += mark[p] ;
    mark[p] = 0 ;
}

void Maintain( int p ) {
    sum[p] = sum[p*2] + sum[p*2+1] ;
}

void Change( int _l , int _r , int l , int r , ll delta , int p ) {
    int m = ( l+r ) /  2 ; 
    Effect( p , l , r ) ;
    if( _l==l && _r==r ) {
        mark[p] += delta ;
        Effect( p , l , r ) ;
        return ;
    }
    if( _r<=m ) Change( _l , _r , l , m , delta , p*2 ) ; else 
        if( _l>m ) Change( _l,_r,m+1,r,delta,p*2+1 ) ;
            else Change( _l , m , l , m , delta , p*2 ) , Change( m+1,_r,m+1,r,delta,p*2+1 ) ;
    Effect( p*2 , l , m ) , Effect( p*2+1 , m+1 , r ) ;
    Maintain( p ) ;

}

ll Ask( int tar , int l , int r , int p ) {
    int m = ( l+r ) / 2 ;
    Effect( p , l , r ) ;
    if( l==r ) return sum[p] ;
    if( tar <= m ) return Ask( tar , l , m , p * 2 ) ;
        else return Ask( tar , m+1 , r , p*2+1 ) ;
}

int dsu( int x  ) {
    if( x==ds[x] ) return x ;
    return ds[x] = dsu( ds[x] ) ;
}

void ins( int a , int b ) {
    f[++T].y = b , f[T].l = g[a] , g[a] = T ;
    f[++T].y = a , f[T].l = g[b] , g[b] = T ;
}

int de[N] , l[32][N] , inx[32] , si[N] , tid[N] , dfn ;

ll sig[N] ;

int a[N] ;

int di[N] , sta[N] , top ;

void dfs( int fi ) {
    top = 0 ;
    for( int i = 1 ; i<=n ; i++ ) di[i] = g[i] ;
    sta[++top] = fi ;
    while( top>0 ) {
        int po = sta[top] ;
        if( di[po]==g[po] ) {   
            tid[po] = ++ dfn ;
            for( int i = 1 ; inx[i]<=de[po] ; i++ ) l[i][po] = l[i-1][ l[i-1][po] ] ;
            sig[po] = sig[ l[0][po] ] + a[po] ;
            Change( dfn , dfn , 1 , n , sig[po] , 1 ) ;
        }
        bool fl = 0 ;
        for( int k = di[po] ; k ; k=f[k].l ) if( l[0][po]!=f[k].y ) {
            l[0][ f[k].y ] = po ;
            de[ f[k].y ] = de[po] + 1 ;
            sta[++top] = f[k].y ;
            di[po] = f[k].l ;
            fl = 1 ;
            break ;
        }
        if( !fl ) {
            si[po] += 1 ;
            for( int k = g[po] ; k ; k = f[k].l ) si[po] += si[ f[k].y ] ;
            --top ;
        }
    }
}

struct Qries {
    int typ , a , b ;
}q[M] ;

int col[N] ;

int DSU( int x ) {
    top = 0 ;
    sta[++top] = x ;
    int final = 0 ;
    while( top>0 ) {
        int now = sta[top] ;
        if( final ) {
            col[now] = final ;
            top-- ;
            continue ;
        }
        if( col[now] == now ) {
            final = now ;
            top -- ;
        } else  sta[++top] = col[now] ;
    }
    return final ;
}

ll b[N] ;

ll Upwards( int x , int top ) {
    x = DSU( x ) ;
    ll sigma = 0 ;
    while( x!=top ) {
        ll va = b[x] ;
        Change( tid[x] , tid[x]+si[x]-1 , 1 , n , -va , 1 ) ;
        sigma += b[x] ;
        b[x] = 0 ;
        col[x] = top ;
        x = l[0][x] ;
        x = DSU( x ) ;
    }
    return sigma ;
}

int LCA( int  x , int y ) {
    if( de[x] > de[y] ) swap( x , y ) ;
    for( int sub = de[y]-de[x] , j=0 ; sub ; sub/=2 , j++ ) if( sub % 2 ) 
        y = l[j][y] ;
    if( x==y ) return x ;
    for( int i = 0 ; i>=0 ; ) {
        for( i=30 ; i>=0 ; i-- ) if( l[i][x]!=l[i][y] ) {
            x = l[i][x] , y = l[i][y] ;
        }
    }
    return l[0][x] ;
}

int main() {
    scanf("%d%d",&n,&m ) ;
    for( i=1 ; i<=n ; i++ ) ds[i] = i ;
    for( i=1 ; i<=n ; i++ ) {
        scanf("%d",&a[i] ) ;
        b[i] = a[i] ;
    }
    for( i=1 ; i<=m ; i++ ) {
        scanf("%d%d%d",&q[i].typ , &q[i].a , &q[i].b ) ;
        if( q[i].typ==1 ) {
            if( dsu( q[i].a ) != dsu( q[i].b ) ) {
                ds[ dsu( q[i].a ) ] = dsu( q[i].b ) ;
                ins( q[i].a , q[i].b ) ;
            }
        }
    }
    for( i=1,inx[0]=1 ; i<=30 ; i++ ) inx[i] = inx[i-1] * 2 ;
    for( i=1 ; i<=n ; i++ ) if( tid[i]==0 ) dfs( i ) ;
    for( i=1 ; i<=n ; i++ ) ds[i] = i , col[i] = i ;
    for( i=1 ; i<=m ; i++ ) {
//      printf("%d\n",i ) ;
        if( q[i].typ==1 ) {
            if( dsu( q[i].a ) == dsu( q[i].b ) ) {
                int lca = LCA( q[i].a , q[i].b ) ;
                lca = DSU( lca ) ;
                ll TOT = Upwards( q[i].a , lca ) + Upwards( q[i].b , lca ) ;
                b[lca] += TOT ;
                Change( tid[lca] , tid[lca]+si[lca]-1 , 1 , n , TOT , 1 ) ;
            } else {
                ds[ dsu( q[i].a ) ] = dsu( q[i].b ) ;
            }
        } else if( q[i].typ==2 ) {
            ll delta = q[i].b - a[ q[i].a ] ;
            a[ q[i].a ] = q[i].b ;
            Change( tid[ DSU( q[i].a ) ] , tid[ DSU( q[i].a ) ]+si[ DSU( q[i].a ) ] - 1 , 1 , n , delta , 1 ) ;
            b[ DSU( q[i].a ) ] += delta ;
        } else {
            if( dsu( q[i].a ) != dsu( q[i].b ) ) {
                puts("-1" ) ;
                continue ;
            }
            ll ans = Ask(  tid[ DSU( q[i].a ) ] , 1 , n , 1 ) + Ask(  tid[ DSU( q[i].b ) ] , 1 , n , 1 ) ;
            int lca = LCA( q[i].a , q[i].b ) ;
            lca = DSU( lca ) ;
            ll tmp = Ask(  tid[ lca ] , 1 , n ,1 ) ;
            ans -= 2 * tmp ;
            ans += b[lca] ;
            printf("%lld\n",ans ) ;
        }
    }   
}

DebugLog
在线段树上询问时忘了用tid[]
论手工栈重要性

总结：
遇到询问u—v上的权值和时，可以考虑用线段树维护一个节点到根的权值和。
遇到会形成环的情况积极考虑并查集缩环。