HDU 2586.How far away ？-在线LCA(ST)-代码很认真的写了注释(捞到变形)

2018.9.10 0:40 重新敲一遍，然后很认真的写了注释，方便自己和队友看，刚过去的一天的下午打网络赛有一题用到了这个，但是没写注释，队友改板子有点伤，因为我没注释。。。

以后写博客，代码要写注释，要把题目意思写上。。。

我好捞啊。。。

How far away ？

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 21408    Accepted Submission(s): 8432

Problem Description

There are n houses in the village and some bidirectional roads connecting them. Every day peole always like to ask like this "How far is it if I want to go from house A to house B"? Usually it hard to answer. But luckily int this village the answer is always unique, since the roads are built in the way that there is a unique simple path("simple" means you can't visit a place twice) between every two houses. Yout task is to answer all these curious people.

 

Input

First line is a single integer T(T<=10), indicating the number of test cases.
  For each test case,in the first line there are two numbers n(2<=n<=40000) and m (1<=m<=200),the number of houses and the number of queries. The following n-1 lines each consisting three numbers i,j,k, separated bu a single space, meaning that there is a road connecting house i and house j,with length k(0<k<=40000).The houses are labeled from 1 to n.
  Next m lines each has distinct integers i and j, you areato answer the distance between house i and house j.

 

Output

For each test case,output m lines. Each line represents the answer of the query. Output a bland line after each test case.

 

Sample Input

2

3 2

1 2 10

3 1 15

1 2

2 3

 

2 2

1 2 100

1 2

2 1

 

Sample Output

10
25
100
100

 

Source

ECJTU 2009 Spring Contest

 

 

这个题就是求两点之间的最短距离，就是LCA模板题

 

 

代码:

 //HDU2586
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<bitset>
 #include<cassert>
 #include<cctype>
 #include<cmath>
 #include<cstdlib>
 #include<ctime>
 #include<deque>
 #include<iomanip>
 #include<list>
 #include<map>
 #include<queue>
 #include<set>
 #include<stack>
 #include<vector>
 using namespace std;
 typedef long long ll;

 const double PI=acos(-1.0);
 const double eps=1e-;
 const ll mod=1e9+;
 const int inf=0x3f3f3f3f;
 const int maxn=4e4+;
 const int maxm=+;
 #define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

 int dp[maxn<<][];//数组记得开2倍，因为遍历之后序列长度变为2*n-1
 bool vis[maxn];//标记

 struct node{
     int u,v,w,next;
 }edge[maxn<<];

 int tot,head[maxn];//head保存的是以当前节点为起点的所有边中最后一条边的编号

 int num;

 inline void add(int u,int v,int w)
 {
     edge[num].u=u;edge[num].v=v;edge[num].w=w;//存边和权值
     edge[num].next=head[u];head[u]=num++;//next保存的是以u为起点的上一条边的编号
     u=u^v;v=u^v;u=u^v;//节点互换，存两次，因为为无向图，(u,v)存一次，(v,u)存一次，以下操作同上
     edge[num].u=u;edge[num].v=v;edge[num].w=w;
     edge[num].next=head[u];head[u]=num++;
 }

 int ver[maxn<<],deep[maxn<<],node[maxn<<],dir[maxn<<];
 //ver节点编号，dfs搜索过程中的序列，deep深度，node点编号位置，dir距离

 void dfs(int u,int dep)
 {
     vis[u]=true;//标记u节点被访问过
     ver[++tot]=u;//存dfs序
     node[u]=tot;//节点的dfs序的编号
     deep[tot]=dep;//该编号的深度
     for(int k=head[u];k!=-;k=edge[k].next)//倒着遍历以u节点为起点的所有边的编号
     if(!vis[edge[k].v]){//如果该编号的边未被访问过
         int v=edge[k].v,w=edge[k].w;//v表示该边的终点，w表示该边的权值
         dir[v]=dir[u]+w;//权值和
         dfs(v,dep+);//再往下dfsv节点的深度
         ver[++tot]=u;deep[tot]=dep;//表示dfs的时候还要回溯到上面，就是把dfs序保存一下，走到底再返回去去遍历没走过的点
     }
 }
 //可以看以前写的RMQ(ST)的详解https://www.cnblogs.com/ZERO-/p/8456910.html
 void ST(int n)//ST操作
 {
     for(int i=;i<=n;i++)
         dp[i][]=i;//初始化为自己
     for(int j=;(<<j)<=n;j++){
         for(int i=;i+(<<j)-<=n;i++){
             int a=dp[i][j-],b=dp[i+(<<(j-))][j-];
             dp[i][j]=deep[a]<deep[b]?a:b;
         }
     }
 }

 int RMQ(int l,int r)
 {
     int k=;
     while((<<(k+))<=r-l+)k++;//最多能跳2的多少次幂
     int a=dp[l][k],b=dp[r-(<<k)+][k];//保存的是编号
     return deep[a]<deep[b]?a:b;
 }

 int LCA(int u,int v)
 {
     int x=node[u],y=node[v];
     if(x>y)swap(x,y);
     int res=RMQ(x,y);
     return ver[res];
 }

 int main()
 {
     int cas;
     scanf("%d",&cas);
     while(cas--){
         int n,q;
         num=;
         scanf("%d%d",&n,&q);
         memset(head,-,sizeof(head));//初始化
         memset(vis,false,sizeof(vis));
         for(int i=;i<n;i++){
             int u,v,w;
             scanf("%d%d%d",&u,&v,&w);
             add(u,v,w);//存边
         }
         tot=;dir[]=;
         dfs(,);
         ST(*n-);
         while(q--){
             int u,v;
             scanf("%d%d",&u,&v);
             int lca=LCA(u,v);
             printf("%d\n",dir[u]+dir[v]-*dir[lca]);//两点最短距离为每个点到根节点的距离-最近公共祖先到根节点的距离的*2
         }
     }
     return ;
 }

就这样，捞咸鱼。。。

༼༎ຶᴗ༎ຶ༽