POJ 1986 Distance Queries 【RMQ LCA】双向存边

题目链接

题目大意：求节点a到节点b的最短距离

思路：LCA模版，用dis数组存节点root到根节点的距离，输出 dis[a] + dis[b] - 2*dis[ LCA(a,b) ];

WA坑点：vector要双向存边，不然会WA，虽然不知道为什么要双向存边，记住就好

AC代码：

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <vector>
#include <string.h>
#define N 100100

using namespace std;

struct node
{
    int x,len;
};
vector<node> vec[N];
int depth[2*N],id[N],vs[2*N],k,dp[2*N][30];
long long dis[2*N];

int MIN(int a, int b)
{
    if(depth[a] <= depth[b])
        return a;
    return b;
}

void RMQ(int n)
{
    for(int i = 1; i <= n; i++)
        dp[i][0] = i;
    for(int j = 1; (1<<j) <= n; j++)
        for(int i = 1; i+(1<<j)-1 <= n; i++)
            dp[i][j] = MIN(dp[i][j-1], dp[i+(1<<(j-1))][j-1]);
}

void dfs(int root, int d, int len,int f)
{
    id[root] = k;
    dis[k] = len;
    vs[k] = root;
    depth[k++] = d;
    for(int i = 0; i < vec[root].size(); i++)
    {
        if(vec[root][i].x == f)
            continue;
        dfs(vec[root][i].x, d+1, len+vec[root][i].len,root);
        vs[k] = root;
        dis[k] = len;
        depth[k++] = d;
    }
}

int query(int l, int r)
{
    if(l > r)
        swap(l,r);
    int k = (int)(log10(r-l+1)/log10(2));
    return MIN(dp[l][k], dp[r-(1<<k)+1][k]);
}

int main()
{
    int n,m,a,b,l,in[N],q;
    char ch;
    while(cin>>n>>m)
    {
        for(int i = 0; i < N; i++)
            vec[i].clear();
        memset(in,0,sizeof(in));
        memset(dis,0,sizeof(dis));

        while(m--)
        {
            scanf("%d%d%d %c",&a, &b, &l, &ch);
            node x = {b,l}, y = {a,l};
            vec[a].push_back(x);
            vec[b].push_back(y);
            in[b] = 1;
        }

        int i = 1;
        while(in[i])
            i++;
        k = 1;
        dfs(i,0,0,-1);
        RMQ(2*n-1);

        cin>>q;
        while(q--)
        {
            scanf("%d%d",&a, &b);
            int fi = query(id[a],id[b]);
            printf("%lld\n",dis[id[a]] - 2*dis[fi] + dis[id[b]]);
        }
    }
    return 0;
}