hdu2874(lca / tarjan离线 + RMQ在线)

题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=2874

题意: 给出 n 个顶点 m 条边的一个森林, 有 k 个形如 x y 的询问, 输出 x, y 之间的最短路径.

思路: 如果将森林换成一棵树的话就是一道 lca 模板题了, 不过本题需要稍作改动.

解法1: tarjan

只需要先判断一下 x, y 是否在一颗树里面就 ok 了, 不过这道题的询问有点多, 很容易 mle.

代码:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 using namespace std;

 const int MAXN = 1e4 + ;
 const int MAX = 1e6 + ;
 struct node1{
     int v, w, next;
 }edge1[MAXN << ];

 struct node2{
     int u, v, next;
 }edge2[MAX << ];//edge1记录树, edge2记录询问

 int vis[MAXN], pre[MAXN], dis[MAXN], sol[MAX];//vis[i]标记i是否已经搜索过, pre[i]记录i的根节点, dis[i]记录i到根节点的距离
 int head1[MAXN], head2[MAXN], ip1, ip2, cnt;

 void init(void){
     memset(sol, , sizeof(sol));
     memset(vis, , sizeof(vis));
     memset(dis, , sizeof(dis));
     memset(head1, -, sizeof(head1));
     memset(head2, -, sizeof(head2));
     ip1 = ip2 = cnt = ;
 }

 void addedge1(int u, int v, int w){//前向星
     edge1[ip1].v = v;
     edge1[ip1].w = w;
     edge1[ip1].next = head1[u];
     head1[u] = ip1++;
 }

 void addedge2(int u, int v){
     edge2[ip2].u = u;
     edge2[ip2].v = v;
     edge2[ip2].next = head2[u];
     head2[u] = ip2++;
 }

 int find(int x){
     return pre[x] == x ? x : pre[x] = find(pre[x]);
 }

 void jion(int x, int y){
     x = find(x);
     y = find(y);
     if(x != y) pre[y] = x;
 }

 void tarjan(int u){
     pre[u] = u;
     vis[u] = cnt;//将不同的联通块标记成不同的数字
     for(int i = head1[u]; i != -; i = edge1[i].next){
         int v = edge1[i].v;
         int w = edge1[i].w;
         if(!vis[v]){
             dis[v] = dis[u] + w;
             tarjan(v);
             jion(u, v);
         }
     }
     for(int i = head2[u]; i != -; i = edge2[i].next){
         int v = edge2[i].v;
         if(vis[v] == cnt) sol[i >> ] = find(v);//只有同一个联通块的顶点才存在lca
     }
 }

 int main(void){
     int t, n, m, x, y, z;
     while(~scanf("%d%d%d", &n, &m, &t)){
         init();
         for(int i = ; i < m; i++){
             scanf("%d%d%d", &x, &y, &z);
             addedge1(x, y, z);
             addedge1(y, x, z);
         }
         for(int i = ; i < t; i++){
             scanf("%d%d", &x, &y);
             addedge2(x, y);
             addedge2(y, x);
         }
         for(int i = ; i <= n; i++){
             if(!vis[i]){
                 cnt++;
                 dis[i] = ;//顶点到自己的距离为0
                 tarjan(i);
             }
         }
         for(int i = ; i < t; i++){
             int cc = i << ;
             int u = edge2[cc].u;
             int v = edge2[cc].v;
             int lca = sol[i];//sol开两倍空间会超内存
             if(!lca) puts("Not connected");
             else printf("%d\n", dis[u] + dis[v] -  * dis[lca]);
         }
     }
     return ;
 }

解法2: lca 转 RMQ

可以先拟个虚根, 另外输出前先判一下 x, y 是否在同一棵树里面即可.

代码:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
 using namespace std;

 const int inf = 1e9;
 const int MAXN = 4e4 + ;
 struct node{
     int v, w, next;
 }edge[MAXN << ];

 int dp[MAXN << ][]; //dp[i][j]存储deep数组中下标i开始长度为2^j的子串中最小值的下标
 int first[MAXN], ver[MAXN << ], deep[MAXN << ];
 int vis[MAXN], head[MAXN], dis[MAXN], tag[MAXN], ip, indx, cnt;

 inline void init(void){
     memset(tag, , sizeof(tag));
     memset(vis, , sizeof(vis));
     memset(head, -, sizeof(head));
     ip = ;
     indx = ;
     cnt = ;
 }

 void addedge(int u, int v, int w){
     edge[ip].v = v;
     edge[ip].w = w;
     edge[ip].next = head[u];
     head[u] = ip++;
 }

 void dfs(int u, int h){
     vis[u] = ; //标记已搜索过的点
     ver[++indx] = u; //记录dfs路径
     first[u] = indx; //记录顶点u第一次出现时对应的ver数组的下标
     deep[indx] = h; //记录ver数组中对应下标的点的深度
     for(int i = head[u]; i != -; i = edge[i].next){
         int v = edge[i].v;
         if(!vis[v]){
             dis[v] = dis[u] + edge[i].w;
             dfs(v, h + );
             ver[++indx] = u;
             deep[indx] = h;
         }
     }
 }

 void dfs1(int u){
     tag[u] = cnt;
     for(int i = head[u]; i != -; i = edge[i].next){
         if(!tag[edge[i].v]) dfs1(edge[i].v);
     }
 }

 void ST(int n){
     for(int i = ; i <= n; i++){
         dp[i][] = i;
     }
     for(int j = ; ( << j) <= n; j++){
         for(int i = ; i + ( << j) -  <= n; i++){
             int x = dp[i][j - ], y = dp[i + ( << (j - ))][j - ];
             dp[i][j] = deep[x] < deep[y] ? x : y;
         }
     }
 }

 int RMQ(int l, int r){
     int len = log2(r - l + );
     int x = dp[l][len], y = dp[r - ( << len) + ][len];
     return deep[x] < deep[y] ? x : y;
 }

 int LCA(int x, int y){
     int l = first[x], r = first[y];
     if(l > r) swap(l, r);
     int pos = RMQ(l, r);
     return ver[pos];
 }

 int main(void){
     int n, m, k, x, y, z;
     while(~scanf("%d%d%d", &n, &m, &k)){
         init();
         for(int i = ; i < m; i++){
             scanf("%d%d%d", &x, &y, &z);
             addedge(x, y, z);
             addedge(y, x, z);
         }
         for(int i = ; i <= n; i++){
             if(!tag[i]){
                 cnt++;
                 dfs1(i);
                 addedge(i, , inf); //拟个虚根0
                 addedge(, i, inf);
             }
         }
         dis[] = ;
         dfs(, );
         ST( * n - );
         for(int i = ; i < k; i++){
             scanf("%d%d", &x, &y);
             int lca = LCA(x, y);
             if(tag[x] != tag[y]) puts("Not connected");
             else printf("%d\n", dis[x] + dis[y] -  * dis[lca]);
         }
     }
     return ;
 }