HDU2874+LCA+tarjan

可用tarjan来做。。。

/*
lca+tarjan
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<map>
#include<math.h>
using namespace std;
typedef long long ll;
//typedef __int64 int64;
const int maxn = 10005;
const int maxm = 1000005;

int cnt,head[ maxn ],ex_cnt,ex_head[ maxn ];
struct node{
    int u,next,val;
}edge[ maxn<<4 ],ex_edge[ maxm<<1 ];
void init(){
    cnt = ex_cnt = 0;
    memset( head,-1,sizeof( head ) );
    memset( ex_head,-1,sizeof( ex_head ) );
}
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 belong[ maxn ];//记录两个点是否属于同一棵树
int vis[ maxn ],dis[ maxn ],fa[ maxn ];

void make_set( int x ){
    fa[ x ] = x;
}
int find( int x ){
    if( x==fa[x] ) return x;
    return fa[x] = find( fa[x] );
}

struct node2{
    int u,v;
}query[ maxm ];
int ans[ maxm ];//存储答案

void dfs( int cur,int flag ){
    //if( vis[ cur ]==1 ) return ;
    vis[ cur ] = 1;
    belong[ cur ] = flag;
    for( int i=head[ cur ];i!=-1;i=edge[ i ].next ){
        if( vis[ edge[ i ].u ]==0 ){
            dfs( edge[ i ].u,flag );
        }
    }
    return ;
}

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

int main(){
    int n,m,k;
    //freopen( "in.txt","r",stdin );
    while( scanf("%d%d%d",&n,&m,&k)==3 ){
        init();
        int a,b,c;
        while( m-- ){
            scanf("%d%d%d",&a,&b,&c);
            addedge( a,b,c );
            addedge( b,a,c );
        }
        memset( vis,0,sizeof( vis ) );
        for( int i=1;i<=n;i++ ){
            belong[ i ] = i;
            fa[ i ] = i;
        }
        int cc = 1;//cc表示树的标记
        for( int i=1;i<=n;i++ ){
            if( vis[ i ]==0 ){
                dfs( i,cc );
                cc++;
            }
        }
        for( int i=1;i<=k;i++ ){
            scanf("%d%d",&a,&b);
            if( a!=b ){
                ex_addedge( a,b,i );
                ex_addedge( b,a,i );
            }
            else ex_addedge( a,b,i );
            query[ i ].u = a;
            query[ i ].v = b;
        }
        memset( vis,0,sizeof( vis ) );
        for( int i=1;i<=n;i++ ){
            if( vis[ i ]==0 ){
                tarjan_of_lca( i,0 );
            }
        }
        for( int i=1;i<=k;i++ ){
            if( belong[ query[i].u ]!=belong[ query[i].v ] ) printf("Not connected\n");
            else{
                printf("%d\n",ans[ i ]);
            }
        }
    }
    return 0;
}

或者很简单的dfs。。。

/*

*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<vector>
#include<map>
#include<math.h>
typedef long long ll;
//typedef __int64 int64;
const int maxn = 10005;
const int maxm = 1005;
const int inf = 0x7FFFFFFF;
const double pi = acos(-1.0);
const double eps = 1e-8;
struct node{
    int from,to,next,val;
}edge[ maxn<<2 ];
int cnt,head[ maxn ];
int dis[ maxn ];//与公共祖先的距离
int fa[ maxn ];//当前点的直接父亲
int deep[ maxn ];//与公共祖先的距离
int ace[ maxn ];//公共祖先

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

void addedge( int a,int b,int c ){
    edge[ cnt ].from = a;
    edge[ cnt ].to = b;
    edge[ cnt ].val = c;
    edge[ cnt ].next = head[ a ];
    head[ a ] = cnt++;
}

void dfs( int now,int now_father,int now_ace,int now_deep,int now_dis ){
    fa[ now ] = now_father;
    deep[ now ] = now_deep;
    dis[ now ] = now_dis;
    ace[ now ] = now_ace;
    for( int i=head[ now ];i!=-1;i=edge[ i ].next ){
        int v = edge[ i ].to;
        if( fa[ v ]==-1 )
            dfs( v,now,now_ace,now_deep+1,now_dis+edge[ i ].val );
    }
    return ;
} 
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 ] );
}
int main(){
    int n,m,q;
    while( scanf("%d%d%d",&n,&m,&q)==3 ){
        int a,b,c;
        init();
        while( m-- ){
            scanf("%d%d%d",&a,&b,&c);
            addedge( a,b,c );
            addedge( b,a,c );
        }
        for( int i=1;i<=n;i++ ){
            if( fa[ i ]==-1 ){
                dfs( i,-1,i,0,1 );
            }
        }
        while( q-- ){
            scanf("%d%d",&a,&b);
            if( ace[ a ]==ace[ b ] ){
                int father=find( a,b );
                printf("%d\n",dis[ a ]+dis[ b ]-2*dis[ father ]);
            }
            else printf("Not connected\n");
        }
    }
    return 0;
}