hdu 2586 How far away ？最近公共祖先lca 在线算法(倍增法)/离线算法(Tarjan算法)

最新推荐文章于 2018-12-01 16:57:15 发布

knownothing

最新推荐文章于 2018-12-01 16:57:15 发布

阅读量5.1k

点赞数

分类专栏：树 lca 文章标签： lca

本文链接：https://blog.csdn.net/a601025382s/article/details/10615039

版权

树同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

lca

2 篇文章 0 订阅

订阅专栏

#pragma comment(linker, "/STACK:1024000000,1024000000")  
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=40004;
struct node{
    int to,w;
    node(int a=0,int b=0){to=a;w=b;}
};
vector<node>e[maxn];
int f[maxn],dis[maxn],deep[maxn],p[maxn][20],n;
void dfs(int u,int pre,int t)
{
    int i,num;
    deep[u]=t;//深度
    f[u]=pre;//父节点
    num=e[u].size();
    for(i=0;i<num;i++)
    {
        int v=e[u][i].to;
        if(v!=pre)
        {
            dis[v]=dis[u]+e[u][i].w;//距离跟的距离
            dfs(v,u,t+1);
        }
    }
}
void init()
{
    //p[i][j]表示i结点的第2^j祖先
    int i,j;
    for(j=0;(1<<j)<=n;j++)
        for(i=1;i<=n;i++)
        p[i][j]=-1;
    for(i=1;i<=n;i++)p[i][0]=f[i];
    for(j=1;(1<<j)<=n;j++)
        for(i=1;i<=n;i++)
        if(p[i][j-1]!=-1)
        p[i][j]=p[p[i][j-1]][j-1];//i的第2^j祖先就是i的第2^(j-1)祖先的第2^(j-1)祖先
}
int lca(int a,int b)//最近公共祖先
{
    int i,j;
    if(deep[a]<deep[b])swap(a,b);
    for(i=0;(1<<i)<=deep[a];i++);
    i--;
    //使a，b两点的深度相同
    for(j=i;j>=0;j--)
        if(deep[a]-(1<<j)>=deep[b])
        a=p[a][j];
    if(a==b)return a;
    //倍增法，每次向上进深度2^j，找到最近公共祖先的子结点
    for(j=i;j>=0;j--)
    {
        if(p[a][j]!=-1&&p[a][j]!=p[b][j])
        {
            a=p[a][j];
            b=p[b][j];
        }
    }
    return f[a];
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int m,i,a,b,c,ans;
        scanf("%d%d",&n,&m);
        for(i=1;i<=n;i++)e[i].clear();
        for(i=1;i<n;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            e[a].push_back(node(b,c));
            e[b].push_back(node(a,c));
        }
        dis[1]=0;
        dfs(1,-1,0);//找到各点的深度和各点的父节点以及距离根的距离
        init();     //初始各个点的2^j祖先是谁    
        for(i=0;i<m;i++)
        {
            scanf("%d%d",&a,&b);
            ans=dis[a]+dis[b]-2*dis[lca(a,b)];
            printf("%d\n",ans);
        }
    }
    return 0;
}
/*
    最近公共祖先lca，在线算法/倍增法，模板题。套别人模板自己敲了遍，现在还要回顾下邻接表，哎。。
    用vector，发现爆栈了，汗一个。。
    用#pragma comment(linker, "/STACK:1024000000,1024000000") 开个把栈开大点吧。。hdu可以，别的地方就不清楚了
*/

下面是用邻接表存图，经证明栈内存不够主要应该是在线运算太耗了的缘故吧。。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=40004;
struct node{
    int to,w,next;
}e[maxn*2];
int f[maxn],dis[maxn],deep[maxn],p[maxn][20],n,tt,head[maxn];
void add(int a,int b,int c)
{
    e[tt].to=b;
    e[tt].w=c;
    e[tt].next=head[a];
    head[a]=tt++;
}
void dfs(int u,int pre,int t)
{
    int i,num;
    deep[u]=t;//深度
    f[u]=pre;//父节点
    for(i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        if(v!=pre)
        {
            dis[v]=dis[u]+e[i].w;//距离跟的距离
            dfs(v,u,t+1);
        }
    }
}
void init()
{
    //p[i][j]表示i结点的第2^j祖先
    int i,j;
    for(j=0;(1<<j)<=n;j++)
        for(i=1;i<=n;i++)
        p[i][j]=-1;
    for(i=1;i<=n;i++)p[i][0]=f[i];
    for(j=1;(1<<j)<=n;j++)
        for(i=1;i<=n;i++)
        if(p[i][j-1]!=-1)
        p[i][j]=p[p[i][j-1]][j-1];//i的第2^j祖先就是i的第2^(j-1)祖先的第2^(j-1)祖先
}
int lca(int a,int b)//最近公共祖先
{
    int i,j;
    if(deep[a]<deep[b])swap(a,b);
    for(i=0;(1<<i)<=deep[a];i++);
    i--;
    //使a，b两点的深度相同
    for(j=i;j>=0;j--)
        if(deep[a]-(1<<j)>=deep[b])
        a=p[a][j];
    if(a==b)return a;
    //倍增法，每次向上进深度2^j，找到最近公共祖先的子结点
    for(j=i;j>=0;j--)
    {
        if(p[a][j]!=-1&&p[a][j]!=p[b][j])
        {
            a=p[a][j];
            b=p[b][j];
        }
    }
    return f[a];
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int m,i,a,b,c,ans;
        scanf("%d%d",&n,&m);
        memset(head,-1,sizeof(head));
        tt=0;
        for(i=1;i<n;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);
            add(b,a,c);
        }
        dis[1]=0;
        dfs(1,-1,0);//找到各点的深度和各点的父节点以及距离根的距离
        init();     //初始各个点的2^j祖先是谁
        for(i=0;i<m;i++)
        {
            scanf("%d%d",&a,&b);
            ans=dis[a]+dis[b]-2*dis[lca(a,b)];
            printf("%d\n",ans);
        }
    }
    return 0;
}

下面是离线算法，我想应该不会栈内存不够啊，为什么还是爆。。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=40004;
struct node{
    int to,w;
    node(int a=0,int b=0){to=a;w=b;}
};
int f[maxn],dis[maxn],n,ans[maxn],vis[maxn];
//f[i]并查集所用，记录前继结点
//dis[i]记录个点到跟结点的距离
//ans记录m个询问的答案
//vis标记查询过了的点
vector<node>e[maxn];//记录树
vector<node>q[maxn];//记录所求最短距离的两点
int find(int x)
{
    if(x!=f[x])f[x]=find(f[x]);
    return f[x];
}
void lca(int u)
{
    int i,j,k,v,c;
    for(i=0;i<e[u].size();i++)
    {
        v=e[u][i].to;
        if(vis[v])continue;
        vis[v]=1;
        dis[v]=dis[u]+e[u][i].w;
        lca(v);//深度优先搜索
        f[v]=u;
        for(j=0;j<q[v].size();j++)
        {
            c=q[v][j].to;
            //如果所求两点中的对应点已知，则必定在同一子树上，由于并查集只记录所在子树。所以find(c)，就是最近公共祖先
            if(vis[c]&&ans[q[v][j].w]==-1)
            {
                if(v==c)ans[q[v][j].w]=0;//自成环
                else ans[q[v][j].w]=dis[v]+dis[c]-2*dis[find(c)];
            }
        }
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int i,j,k,a,b,c,m,aa,bb;
        scanf("%d%d",&n,&m);
        for(i=1;i<=n;i++)
        {
            e[i].clear();
            q[i].clear();
            ans[i]=-1;
            f[i]=i;
            vis[i]=0;
        }
        for(i=1;i<n;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            e[a].push_back(node(b,c));
            e[b].push_back(node(a,c));
        }
        for(i=1;i<=m;i++)
        {
            scanf("%d%d",&a,&b);
            q[a].push_back(node(b,i));
            q[b].push_back(node(a,i));
        }
        vis[1]=1;
        dis[1]=0;
        lca(1);
        for(i=1;i<=m;i++)
            printf("%d\n",ans[i]);
    }
    return 0;
}
/*
    最近公共祖先lca 离线算法/Tarjan算法
    
    方法举例说明：
                1
               / \
              2   3
             / \
            4   5
           /   /
          7   8
         / 
        9  
    查询(4,9)：到4时，由于vis[9]=0，所以继续；到9后，最近公共祖先就是f[4]=4（回溯的时候记录父节点）;
    查询(9,8):深度优先搜索，所以到8时才询问；要到8必须回溯到2，在进到8这个子树，所以以记录f[9]=7;f[7]=4;f[4]=2;f[2]=2;所以find(2)=2;
    查询(8,3):跟上条相似，必须回溯1才能到3，而find(8)=1就是最近公共祖先；
    我们可以发现，对于查询的两点，都要在先查询到的点开始，回溯到最近公共祖先，才查询相对应的点。这也就是离线算法的思路了。。这是我自己理解的。。
    
    下面是专业说明，反正我是没看懂。。
    
    利用并查集优越的时空复杂度，我们可以实现LCA问题的O(n+Q)算法，这里Q表示询问的次数。
    Tarjan算法基于深度优先搜索的框架，对于新搜索到 的一个结点，首先创建由这个结点构成的集合，
    再对当前结点的每一个子树进行搜索，每搜索完一棵子树，则可确定子树内的LCA询问都已解决。
    其他的LCA询问的结果必然在这个子树之外，这时把子树所形成的集合与当前结点的集合合并，并将当前结点设为这个集合的祖先。
    之后继续搜索下一棵子树，直到当前结点的所 有子树搜索完。这时把当前结点也设为已被检查过的，
    同时可以处理有关当前结点的LCA询问，如果有一个从当前结点到结点v的询问，
    且v已被检查过，则由于 进行的是深度优先搜索，当前结点与v的最近公共祖先一定还没有被检查，
    而这个最近公共祖先的包涵v的子树一定已经搜索过了，那么这个最近公共祖先一定是v 所在集合的祖先。
*/

knownothing

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
hdu 2586 How far away ？最近公共祖先lca 在线算法(倍增法)/离线算法(Tarjan算法)

#pragma comment(linker, "/STACK:1024000000,1024000000") #include #include #include #include #include #include using namespace std;const int maxn=40004;struct node{ int to,w; node(int
复制链接

扫一扫