POJ-1986-Distance Queries 解题报告

       跪了接近一个星期的题，坑死了的LCA。题意：农夫的牛们拒绝进行马拉松比赛，为此，农夫很苦恼，你应该帮助农夫找到两个地方之间最短的路程，输入每条路连接的两个地方的编号以及长度，保证图是一颗树，绝对没有环哦！现在给你若干个询问，问两个地方之间的最短路程。

       我的解题思路：这题没办法跪了好久，本来还打算用在线算法去做，不过节点和路够多，貌似用vector来存图会超时，后来不得已用离线的Tarjan算法终于才过了，但是貌似还是不如手写邻接表存图的快。由于是无向图，可以让任意一点作为根节点，然后我们DFS求LCA的同时可以顺便求出每个点与根节点之间的距离，假设用dist[i]表示i到根节点的距离，那么很明显我们求a和b的最短路程应该是这样一个式子：dist[a] + dist[b] - 2 * dist[lca(a, b)]。

       我的解题代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <string>
#include <vector>

using namespace std;

#define N 100040

struct edge
{
    int next;
    int len;
};

struct query    //询问的结构体
{
    int next;
    int id;     //询问的编号，因为要按顺序输出答案
};

vector <edge> e[N];
vector <query> q[N];
bool vis[N];
int dist[N];
int father[N];
int lca[N];
int ans[N];
int n, m, qn;

void InitRead();

int Find(int x);

void DataProcess();

void Dfs(int x, int d);

int main()
{
    while (~scanf("%d %d", &n, &m))
    {
        InitRead();
        DataProcess();
    }
    return 0;
}

void InitRead()
{
    memset(vis, false, sizeof(vis));
    memset(dist, 0, sizeof(dist));
    memset(lca, 0, sizeof(lca));
    for (int i=1; i<=n; ++i)
    {
        e[i].clear();
        q[i].clear();
        father[i] = i;
    }
    edge x;
    int a, b, c;
    for (int i=0; i<m; ++i)
    {
        scanf("%d %d %d %*c", &a, &b, &c);
        x.next = b;
        x.len = c;
        e[a].push_back(x);
        x.next = a;
        e[b].push_back(x);
    }
    scanf("%d", &qn);
    query y;
    for (int i=0; i<qn; ++i)
    {
        scanf("%d %d", &a, &b);
        y.id = i;
        y.next = b;
        q[a].push_back(y);
        y.next = a;
        q[b].push_back(y);
    }
    return;
}

void DataProcess()
{
    Dfs(1, 0);
    for (int i=0; i<qn; ++i)
    {
        printf("%d\n", ans[i]);
    }
    return;
}

void Dfs(int x, int d)
{
    lca[x] = x;
    dist[x] = d;
    vis[x] = true;
    int size = e[x].size();
    for (int i=0; i<size; ++i)
    {
        if (vis[e[x][i].next]) continue;
        Dfs(e[x][i].next, d + e[x][i].len);
        father[e[x][i].next] = x;
    }
    size = q[x].size();
    for (int i=0; i<size; ++i)
    {
        if (vis[q[x][i].next]) ans[q[x][i].id] = dist[x] + dist[q[x][i].next] - 2 * dist[lca[Find(q[x][i].next)]];
    }
    return;
}

int Find(int x)
{
    int z, y = x;
    while (y != father[y])
    {
        y = father[y];
    }
    while (x != father[x])
    {
        z = father[x];
        father[x] = y;
        x = z;
    }
    return y;
}