poj1986 (LCA)

poj1986

给我们一棵树，求任意两个点之间的距离

dist[a->b] = dist[a] +dist[b] - 2*lca(a,b)

要建双向边，数据可能不是严格意义上的树

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <math.h>
using namespace std;
#pragma warning(disable:4996)
typedef long long LL;                   
const int INF = 1<<30;
/*

*/
struct Edge
{
    int to,dist;
};
const int MAX_LOG_V = 100;
const int MAX_V = 100000+10;
int parent[MAX_LOG_V][MAX_V];
int depth[MAX_V];
int dist[MAX_V];
vector<Edge> g[MAX_V];
void dfs(int u, int fa, int d)
{
    parent[0][u] = fa;
    depth[u] = d;
    for(int i=0; i<g[u].size(); ++i)
        if(g[u][i].to!=fa)
        {
            dist[g[u][i].to] = dist[u] + g[u][i].dist;
            dfs(g[u][i].to,u,d+1);
        }    
}
void init(int root, int n)
{
    dfs(root,-1,0);
    //预处理出parent
    for(int k=0; k+1<MAX_LOG_V; ++k)
    {
        for(int v=1; v<=n; ++v)
        {
            if(parent[k][v]<0)
                parent[k+1][v] = -1;
            else
                parent[k+1][v] = parent[k][parent[k][v]];
        }
    }
}
int lca(int u, int v)
{
    if(depth[u] < depth[v])
        swap(u,v);
    //让u和v走到同一生度
    for(int k=0; k<MAX_LOG_V; ++k)
        if((depth[u]-depth[v])>>k&1)//一个数能分解成多个二进制数相加，所以如果&1 为true，那么就向上走
            u = parent[k][u];
    if(u==v) return u;
    //达到同一深度后，二分搜索lca
    
    for(int k=MAX_LOG_V-1; k>=0; --k)
        if(parent[k][v]!=parent[k][u])
        {//我们并不知道要向上走多少步，但是只要每次走后，
        //parent[k][v]!=parent[k][u],那么这一步就可以向上走，即将要走的步数分解为 1 + 2 + 4 + 8 + ...最后一步将在循环结束后走出
            u = parent[k][u];
            v = parent[k][v];
        }
    return parent[0][u];
}

int main()
{
    int n,a,m,i,b,t,root,c;
    char str[2];
    Edge tmp;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        
        for(i=1; i<=n; ++i)
        {
            parent[0][i] = -1;
            g[i].clear();
        }
        for(i=0; i<n-1; ++i)
        {
            scanf("%d%d%d%s",&a,&b,&c,str);
            tmp.to = b;
            tmp.dist = c;
            g[a].push_back(tmp);
            tmp.to = a;
            g[b].push_back(tmp);
        }
        root = 1;
        dist[root] = 0;
        init(root,n);
        scanf("%d",&m);
        for(i=0; i<m; ++i)
        {
            scanf("%d%d",&a,&b);
            int LCA = lca(a,b);
            printf("%d
",dist[a]-dist[LCA] + dist[b]-dist[LCA]);
        }
        
        
    }
    
    return 0;
}