poj1986 Distance Queries（LCA）

带权重 每条边 求两个点之间权重

如果确定根为1，则有Dist(u，v) = Dist(1，u) + Dist(1，v) - 2*Dist( 1，LCA(u，v) )。

7 6

1 6 13 E

6 3 9 E

3 5 7 S

4 1 3 N

2 4 20 W

4 7 2 S

3

1 6

1 4

2 6

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>

using namespace std;

const int maxn = 80080;
const int quest = 20020;

int pre[maxn], head[maxn], qhead[maxn], dist[maxn];

struct node{
int to;
int next;
int lca;}edge[maxn];

node q[maxn];

int finn(int x)
{
while(x != pre[x])
{
x = pre[x];
}
return x;
}

bool vis[maxn];

void LCA(int u)
{
pre[u] = u;
vis[u] = true;
for(int k = head[u]; k != -1; k = edge[k].next)
{
if(!vis[edge[k].to])
{
dist[edge[k].to] = dist[u] + edge[k].lca;
LCA(edge[k].to);
pre[edge[k].to] = u;
}
}
for(int k = qhead[u]; k != -1; k = q[k].next)
{
if(vis[q[k].to])
{
q[k].lca = dist[u] + dist[q[k].to] - 2 * dist[finn(q[k].to)];
q[k^1].lca = q[k].lca;
}
}
}

int main()
{
int n, m, k, u, v, w, a, b;
char s;
while(~scanf("%d%d", &n, &m))
{
memset(head, -1, sizeof(head));
memset(qhead, -1, sizeof(qhead));
memset(vis, false, sizeof(vis));
memset(edge, 0, sizeof(edge));
memset(q, 0, sizeof(q));
memset(dist, 0, sizeof(dist));
int id = 0;
for(int i = 0; i < m; i++)
{
scanf("%d%d%d %c", &u, &v, &w, &s);
edge[id].to = v;
edge[id].lca = w;
edge[id].next = head[u];
head[u] = id++;
edge[id].to = u;
edge[id].lca = w;
edge[id].next = head[v];
head[v] = id++;
}
scanf("%d", &k);
int iq = 0;
for(int i = 0; i < k; i++)
{
scanf("%d%d", &a, &b);
q[iq].to = b;
q[iq].next = qhead[a];
qhead[a] = iq++;
q[iq].to = a;
q[iq].next = qhead[b];
qhead[b] = iq++;
}
LCA(1);
for(int i = 0; i < iq; i+= 2)
{
printf("%d\n", q[i].lca);
}
}
}

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;
const int maxn = 100010;

int n, m, k;
int ancestor[maxn];
int pre[maxn];
int first[maxn];
int next[maxn];
int dis[maxn];
int vis[maxn];
vector<int> v[maxn];
struct node{
int x;
int y;
int value;
int ans;}e[maxn], q[maxn];//保存读入边和询问边

void init()
{
for(int i = 1; i <= n; i++)
{
pre[i] = i;
v[i].clear();
}
memset(ancestor, 0, sizeof(ancestor));
memset(first, -1, sizeof(first));
memset(next, -1, sizeof(next));
memset(dis, 0, sizeof(dis));
memset(vis, 0, sizeof(vis));
}
/*
int finn(int x)
{
if(x != pre[x])
{
pre[x] = finn(pre[x]);
}
return pre[x];
}
*/
int finn(int x)
{
int z, y = x;
while(y != pre[y])
{
y = pre[y];
}
while(x != pre[x])
{
z = pre[x];
pre[x] = y;
x = z;
}
return y;
}
void join(int x, int y)
{

x = finn(x);
y = finn(y);
pre[x] = y;
}

void LCA(int u)
{
ancestor[u] = u;
vis[u] = 1;//标记为处理过
for(int i = first[u]; i != -1; i = next[i])
{
if(!vis[e[i].y])//找到没被处理的点
{
dis[e[i].y] = dis[u] + e[i].value;//更新dis数组
LCA(e[i].y);//继续搜索子树
join(e[i].y,u);//合并
ancestor[finn(e[i].y)] = u; //当前节点为子树的祖先
}
}
//处理u和v[u][i]有关的询问
for(int i = 0; i < v[u].size(); i++)
{
if(vis[v[u][i]])
{
for(int j = 0; j < k; j++)
{
if(q[j].x == u && q[j].y == v[u][i] || q[j].x == v[u][i] && q[j].y == u)
{
q[j].ans = pre[finn(v[u][i])];
}
}
}
}
}

int main()
{
char c;
while(scanf("%d%d", &n, &m) != EOF)
{
init();
for(int i = 0; i < m; i++)
{
scanf("%d %d %d %c" , &e[i].x , &e[i].y , &e[i].value , &c);
//邻接表存储无向图
e[i + m].x = e[i].y;
e[i + m].y = e[i].x;
e[i + m].value = e[i].value;

next[i] = first[e[i].x];
first[e[i].x] = i;
next[i + m] = first[e[i + m].x];
first[e[i + m].x] = i + m;
}
scanf("%d", &k);
for(int i = 0; i < k; i++)
{
scanf("%d%d", &q[i].x, &q[i].y);
v[q[i].x].push_back(q[i].y);
v[q[i].y].push_back(q[i].x);
}
LCA(1);//1作为根节点求lca
for(int i = 0; i < k; i++)
{
int tmp = dis[q[i].x] + dis[q[i].y] - 2 * dis[q[i].ans];
printf("%d\n", tmp);
}
}
return 0;
}