PKU1986+LCA

wa的代码。。纯dfs

/*
LCA
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<map>
#include<math.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
typedef long long ll;
//typedef __int64 int64;
const int maxn = 40005;
const int inf = 0x7fffffff;
const double pi=acos(-1.0);
const double eps = 1e-8;

int dis[ maxn ],ace[ maxn ],deep[ maxn ],fa[ maxn ];
int cnt,head[ maxn ];
struct node{
    int u,next,val;
}edge[ maxn<<4 ];
void init(){
    cnt = 0;
    memset( head,-1,sizeof( head ) );
    memset( fa,0,sizeof( fa ) );
}
void addedge( int a,int b,int c ){
    edge[ cnt ].u = b;
    edge[ cnt ].val = c;
    edge[ cnt ].next = head[ a ];
    head[ a ] = cnt++;
}
int find( int x,int y ){
    if( x==y ) return x;
    if( deep[ x ]>deep[ y ] ) return find( fa[x],y );
    else return find( x,fa[y] );
}
void dfs( int now,int now_father,int now_ace,int now_deep,int now_dis ){
    fa[ now ] = now_father;
    ace[ now ] = now_ace;
    deep[ now ] = now_deep;
    dis[ now ] = now_dis;
    for( int i=head[ now ];i!=-1;i=edge[ i ].next ){
        int v = edge[ i ].u;
        if( fa[ v ]==0 ){
            dfs( v,now,now_ace,now_deep+1,now_dis+edge[ i ].val );
        }
    }
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
        int a,b,c;
        char s[2];
        init();
        while( m-- ){
            scanf("%d%d%d%s",&a,&b,&c,s);
            addedge( a,b,c );
            addedge( b,a,c );
        }
        for( int i=1;i<=n;i++ ){
            if( fa[i]==0 ){
                dfs( i,-1,i,0,0 );
            }
        }
        int k;
        scanf("%d",&k);
        while( k-- ){
            scanf("%d%d",&a,&b);
            int father = find( a,b );
            printf("%d\n",dis[a]+dis[b]-2*dis[father]);
        
        }
    
    return 0;
}

tarjan算法。。

/*
LCA+tarjan
计算一棵树中任意两点之间的距离
*/
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
using namespace std;
const int maxn = 40005;
int dis[ maxn ],vis[ maxn ],fa[ maxn ];
struct node{
    int u,next,val;
}edge[ maxn<<2 ],ex_edge[ maxn ];
int cnt,head[ maxn ],ex_cnt,ex_head[ maxn ];
int ans[ maxn ];

void init(){
    cnt = ex_cnt = 0;
    memset( head,-1,sizeof( head ) );
    memset( ex_head,-1,sizeof( ex_head ) );
    memset( vis,0,sizeof( vis ) );
    memset( fa,-1,sizeof( fa ) );
    memset( dis,0,sizeof( dis ) );
}

void addedge( int a,int b,int c ){
    edge[ cnt ].u = b;
    edge[ cnt ].val = c;
    edge[ cnt ].next = head[ a ];
    head[ a ] = cnt++;
}
void ex_addedge( int a,int b,int c ){
    ex_edge[ ex_cnt ].u = b;
    ex_edge[ ex_cnt ].val = c;
    ex_edge[ ex_cnt ].next = ex_head[ a ];
    ex_head[ a ] = ex_cnt++;
}

int find( int x ){
    if( fa[x]==-1 ) return x;
    fa[x] = find( fa[x] );
    return fa[x];
}

void tarjan( int u,int dist ){
    vis[ u ] = 1;
    dis[ u ] = dist;
    for( int i=ex_head[ u ];i!=-1;i=ex_edge[ i ].next ){
        int v = ex_edge[ i ].u;
        if( vis[ v ]==1 ){
            ans[ ex_edge[ i ].val ] = dis[ u ]+dis[ v ]-2*dis[ find(v) ];
        }
    }
    for( int i=head[ u ];i!=-1;i=edge[ i ].next ){
        int v = edge[ i ].u;
        if( vis[v]==0 ){
            tarjan( v,dist+edge[ i ].val );
            fa[ v ] = u;
        }
    }
}

int main(){
    int n,m;
    while( scanf("%d%d",&n,&m)==2 ){
        int a,b,c;
        char s[2];
        init();
        for( int i=0;i<m;i++ ){
            scanf("%d%d%d%s",&a,&b,&c,s);
            addedge( a,b,c );
            addedge( b,a,c );
        }
        int k;
        scanf("%d",&k);
        for( int i=0;i<k;i++ ){
            scanf("%d%d",&a,&b);
            ex_addedge( a,b,i );
            ex_addedge( b,a,i );
        }
        tarjan( 1,0 );//因为这是一棵树 任选1为root，tarjan( i,dis ):表示i到root的距离为dis
        for( int i=0;i<k;i++ ){
            printf("%d\n",ans[i]);
        }
    }
    return 0;
}