hdu 2874(裸LCA)

传送门

•题意

　　在一个包含 n 个节点 m 条边的森林中；

　　有 q 次询问，每次询问求解两点间的最短距离；

　　如果这两点不联通，输出 "Not connected"；

•题解1

　　树上任意两点间的最短距离就是最近公共祖先分别到这两点的距离和；

　　那么这个问题就被转化成了LCA问题。

　　因为有多棵树，所以，对于每棵树，都提前预处理出 $dis,dep$；

　　并通过并查集判断询问的两点是否联通；

•Code

 #include<bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define mem(a,b) memset(a,b,sizeof(a))
 const int maxn=1e4+;

 int n,m,q;
 int num;
 int head[maxn];
 struct Edge
 {
     int to;
     ll w;
     int next;
 }G[maxn<<];
 void addEdge(int u,int v,ll w)
 {
     G[num]={v,w,head[u]};
     head[u]=num++;
 }
 vector<int >V[maxn];
 /**
     fa[i][j]:节点j沿着其父结点向上走2^i步所到的节点（超过根节点时记为-1）
     ///dis[i]:节点i的与根节点的距离
     ///dep[i]:节点i的深度，根节点深度为0
 */
 struct LCA
 {
     int fa[][maxn];
     ll dis[maxn];
     ll dep[maxn];
     void DFS(int u,int f,ll Dis,ll Dep)
     {
         fa[][u]=f;///节点u向上走2^0步来到的节点便是其父节点
         dis[u]=Dis;
         dep[u]=Dep;
         for(int i=head[u];~i;i=G[i].next)
         {
             int v=G[i].to;
             ll w=G[i].w;
             if(v != f)
                 DFS(v,u,Dis+w,Dep+);
         }
     }
     void Init()
     {
         for(int i=;i <= n;++i)
         {
             if(V[i].empty())
                 continue;
             ///预处理出每棵树的dis,dep,fa
             DFS(V[i][],-,,);
             for(int k=;k <= ;++k)
                 for(int j=;j < V[i].size();++j)
                 {
                     int u=V[i][j];
                     if(fa[k-][u] == -)
                         fa[k][u]=-;
                     else
                         fa[k][u]=fa[k-][fa[k-][u]];
                 }
         }
     }
     int lca(int u,int v)///返回u,v的最近公共祖先
     {
         if(dep[u] > dep[v])
             swap(u,v);

         for(int i=;i <= ;++i)
             if((dep[v]-dep[u])>>i&)
                 v=fa[i][v];
         if(u == v)
             return u;

         for(int i=;i >= ;--i)
             if(fa[i][u] != fa[i][v])
             {
                 u=fa[i][u];
                 v=fa[i][v];
             }
         return fa[][u];
     }
 }_lca;
 struct Set
 {
     int fa[maxn];
     void Init()
     {
         for(int i=;i <= n;++i)
             fa[i]=i;
     }
     int Find(int x)
     {
         return x == fa[x] ? x:fa[x]=Find(fa[x]);
     }
     void Union(int x,int y)
     {
         x=Find(x);
         y=Find(y);
         if(x != y)
             fa[x]=y;
     }
 }_set;
 void Solve()
 {
     for(int i=;i <= n;++i)///将属于同一颗树的节点存在_set.fa[i]中
         V[_set.Find(i)].push_back(i);///并查集查找i的祖先节点用Find()
     _lca.Init();

     while(q--)
     {
         int u,v;
         scanf("%d%d",&u,&v);
         if(_set.Find(u) != _set.Find(v))///判断u,v是否属于同一棵树用Find()
             puts("Not connected");
         else
         {
             int x=_lca.lca(u,v);
             ll ans=_lca.dis[u]+_lca.dis[v]-*_lca.dis[x];
             printf("%lld\n",ans);
         }
     }
 }
 void Init()
 {
     num=;
     for(int i=;i <= n;++i)
     {
         head[i]=-;
         V[i].clear();
     }
     _set.Init();
 }
 int main()
 {
 //    freopen("C:\\Users\\hyacinthLJP\\Desktop\\C++WorkSpace\\in&&out\\contest","r",stdin);
     while(~scanf("%d%d%d",&n,&m,&q))
     {
         Init();
         for(int i=;i <= m;++i)
         {
             int u,v,w;
             scanf("%d%d%d",&u,&v,&w);
             addEdge(u,v,w);
             addEdge(v,u,w);
             _set.Union(u,v);
         }
         Solve();
     }
     return ;
 }

基于二分的LCA

•题解2

　　通过添加虚点将森林转化成一棵树；

　　并以添加的虚点作为这棵树的根节点；

　　对于询问操作，如果询问的两点的 $LCA$ 为虚点，那么这两点在原森林中不连通；

　　这么做的话，只需处理一棵树的 $dis,dep,fa$；

•Code

 #include<bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define mem(a,b) memset(a,b,sizeof(a))
 const int maxn=1e4+;

 int n,m,q;
 int num;
 int head[maxn];
 struct Edge
 {
     int to;
     ll w;
     int next;
 }G[maxn<<];
 void addEdge(int u,int v,ll w)
 {
     G[num]={v,w,head[u]};
     head[u]=num++;
 }
 /**
     fa[i][j]:节点j沿着其父结点向上走2^i步所到的节点（超过根节点时记为-1）
     ///dis[i]:节点i的与根节点的距离
     ///dep[i]:节点i的深度，根节点深度为0
 */
 struct LCA
 {
     int fa[][maxn];
     ll dis[maxn];
     ll dep[maxn];
     void DFS(int u,int f,ll Dis,ll Dep)
     {
         fa[][u]=f;///节点u向上走2^0步来到的节点便是其父节点
         dis[u]=Dis;
         dep[u]=Dep;
         for(int i=head[u];~i;i=G[i].next)
         {
             int v=G[i].to;
             ll w=G[i].w;
             if(v != f)
                 DFS(v,u,Dis+w,Dep+);
         }
     }
     void Init()
     {
         DFS(n+,-,,);
         for(int k=;k <= ;++k)
             for(int u=;u <= n+;++u)
                 if(fa[k-][u] == -)
                     fa[k][u]=-;
                 else
                     fa[k][u]=fa[k-][fa[k-][u]];
     }
     int lca(int u,int v)///返回u,v的最近公共祖先
     {
         if(dep[u] > dep[v])
             swap(u,v);

         for(int i=;i <= ;++i)
             if((dep[v]-dep[u])>>i&)
                 v=fa[i][v];
         if(u == v)
             return u;

         for(int i=;i >= ;--i)
             if(fa[i][u] != fa[i][v])
             {
                 u=fa[i][u];
                 v=fa[i][v];
             }
         return fa[][u];
     }
 }_lca;
 struct Set
 {
     int fa[maxn];
     void Init()
     {
         for(int i=;i <= n+;++i)
             fa[i]=i;
     }
     int Find(int x)
     {
         return x == fa[x] ? x:fa[x]=Find(fa[x]);
     }
     void Union(int x,int y)
     {
         x=Find(x);
         y=Find(y);
         if(x != y)
             fa[x]=y;
     }
 }_set;
 void Solve()
 {
     _lca.Init();

     while(q--)
     {
         int u,v;
         scanf("%d%d",&u,&v);
         int x=_lca.lca(u,v);
         if(x == n+)
             puts("Not connected");
         else
         {
             ll ans=_lca.dis[u]+_lca.dis[v]-*_lca.dis[x];
             printf("%lld\n",ans);
         }
     }
 }
 bool vis[maxn];
 void Init()
 {
     num=;
     for(int i=;i <= n+;++i)
     {
         head[i]=-;
         vis[i]=false;
     }
     _set.Init();
 }
 int main()
 {
 //    freopen("C:\\Users\\hyacinthLJP\\Desktop\\C++WorkSpace\\in&&out\\contest","r",stdin);
     while(~scanf("%d%d%d",&n,&m,&q))
     {
         Init();
         for(int i=;i <= m;++i)
         {
             int u,v,w;
             scanf("%d%d%d",&u,&v,&w);
             addEdge(u,v,w);
             addEdge(v,u,w);
             _set.Union(u,v);
         }
         ///定义虚节点 n+1
         ///将节点n+1与连接每棵树的某个节点
         ///每棵树只有一个节点与节点n+1相连，边仅加一次
         for(int i=;i <= n;++i)
             if(!vis[_set.Find(i)])///此处用Find(i)而不是用fa[i]
             {
                 addEdge(n+,_set.Find(i),);
                 vis[_set.Find(i)]=true;
             }

         Solve();
     }
     return ;
 }

基于二分的LCA