JZOJ3395. 【NOIP2013模拟】Freda的传呼机

题目大意

给一个包含N个节点和M条双向边的图(保证每条边只会最多出现在一个环中,即仙人掌)和Q个询问。
输入x,y,t表示x,y之间有一条长度为t的双向边。
接下来Q个询问，每个询问(u,v)求(u,v)间的最短距离。
对于100%的数据，2<=N<=10000，N-1<=M<=12000，Q=10000，1<=x，y<=N，1<=t<=32768.

题解

如果图中没有环，也就是一棵树，那么这题就很简单了，直接先BFS，然后对于每个询问(u,v)，其答案就是$dist[u]+dist[v]-2*dist[LCA]$，其中$dist[i]$表示起点(这题可以任取)到节点i的距离。正确性显然。
那么，如果现在的图有环，那就是一颗仙人掌了(业界毒瘤)。比较直观的想法是先缩环。对于一对(u,v)如果他们到LCA前经过了同一个环，那么答案就可能不是上述的那种了，因为有可能另一半环上的距离最优。一个比较机智的做法是缩环的时候记录一下当前环上一一个起点，按某一方向走到环上当前点的距离。那么另一个方向就是总长度-当前下的长度。两者取一个min就是最优的了。
至于缩环可以直接Tarjan。

SRC

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

#define N 240000 + 10
const int MX = 20 ;

bool bz[2*N] , issame ;
int Node[2*N] , Next[2*N] , W[2*N] , Head[N] , tot = 1 ;
int d[2*N] , dist[N] , DFN[N] , preE[N] ;
int L[N] , Len[N] , from[N] ;
int deep[N] , f[N][25] ;
int n , m , Q , fx , fy , Time , totc ;

void link( int u , int v , int w ) {
    Node[++tot] = v ;
    W[tot] = w ;
    Next[tot] = Head[u] ;
    Head[u] = tot ;
}

void SPFA() {
    int i = 0 , j = 1 ;
    memset( dist , 63 , sizeof(dist) ) ;
    d[1] = 1 ;
    bz[1] = 1 ;
    dist[1] = 0 ;
    while ( i < j ) {
        i ++ ;
        int now = d[i] ;
        for (int p = Head[now] ; p ; p = Next[p] ) {
            if ( dist[now] + W[p] < dist[Node[p]] ) {
                dist[Node[p]] = dist[now] + W[p] ;
                if ( !bz[Node[p]] ) {
                    bz[Node[p]] = 1 ;
                    d[++j] = Node[p] ;
                    if ( dist[d[j]] < dist[d[i+1]] ) swap( d[j] , d[i+1] ) ;
                }
            }
        }
        bz[now] = 0 ;
    }
}

void DelCir( int st , int ed ) {
    from[ed] = totc ;
    for (int x = st ; x != ed ; x = Node[preE[x]^1] ) {
        int E = preE[x] ^ 1 ;
        L[totc] += W[E] ;
        bz[E] = bz[E^1] = 1 ;
        from[x] = totc ;
        link( ed , x , 0 ) ;
        link( x , ed , 0 ) ;
    }
}

void solve( int x ) {
    DFN[x] = ++ Time ;
    for (int p = Head[x] ; p ; p = Next[p] ) {
        if ( p == (preE[x] ^ 1) || p > m * 2 + 1  ) continue ;
        if ( !DFN[Node[p]] ) {
            preE[Node[p]] = p ;
            Len[Node[p]] = Len[x] + W[p] ;
            solve( Node[p] ) ;
        }
        if ( DFN[Node[p]] < DFN[x] ) L[++totc] = W[p] , bz[p] = bz[p^1] = 1 , DelCir( x , Node[p] ) ;
    }
}

void DFS( int x ) {
    for (int p = Head[x] ; p ; p = Next[p] ) {
        if ( bz[p] || Node[p] == f[x][0] ) continue ;
        deep[Node[p]] = deep[x] + 1 ;
        f[Node[p]][0] = x ;
        DFS( Node[p] ) ;
    }
}

int LCA( int x , int y ) {
    if ( deep[x] < deep[y] ) swap( x , y ) ;
    for (int i = MX ; i >= 0 ; i -- ) if ( deep[f[x][i]] >= deep[y] ) x = f[x][i] ;
    if ( x == y ) return x ;
    for (int i = MX ; i >= 0 ; i -- ) if ( f[x][i] != f[y][i] ) x = f[x][i] , y = f[y][i] ;
    if ( from[x] && from[x] == from[y] ) issame = 1 , fx = x , fy = y ;
    return f[x][0] ;
}

int main() {
    scanf( "%d%d%d" , &n , &m , &Q ) ;
    for (int i = 1 ; i <= m ; i ++ ) {
        int x , y , t ;
        scanf( "%d%d%d" , &x , &y , &t ) ;
        link( x , y , t ) ;
        link( y , x , t ) ;
    }
    SPFA() ;
    memset( bz , 0 , sizeof(bz) ) ;
    solve( 1 ) ;
    deep[1] = 1 ;
    DFS( 1 ) ;
    for (int j = 1 ; j <= MX ; j ++ ) {
        for (int i = 1 ; i <= n ; i ++ ) {
            f[i][j] = f[f[i][j-1]][j-1] ;
        }
    }
    for (int i = 1 ; i <= Q ; i ++ ) {
        int x , y , F ;
        scanf( "%d%d" , &x , &y ) ;
        issame = 0 ;
        F = LCA( x , y ) ;
        printf( "%d\n" , dist[x] + dist[y] - (!issame) * 2 * dist[F] + issame * ( - dist[fx] - dist[fy] + min( abs( Len[fx] - Len[fy] ) , L[from[fx]] - abs( Len[fx] - Len[fy]) )) ) ;
    }
    return 0 ;
}

以上.