RMQ转换LCA模板 ST算法

最新推荐文章于 2023-11-08 20:34:56 发布
最新推荐文章于 2023-11-08 20:34:56 发布
阅读量893 收藏 2
点赞数
分类专栏： ===图论=== LCA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Forever_wjs/article/details/52160217
版权

原理：

void dfs(int k,int d,long long sum)
{
    cost[k]=sum;
    pos[k]=++tot; ///记录第一次出现的时间戳
    F[tot]=k; ///记录欧拉序列
    rmq[tot]=d;///记录该时间戳深度
    vis[k]=1;
    for(int i=fir[k];~i;i=nex[i])
    {
        int e=v[i];
        if(!vis[e])
        {
            dfs(e,d+1,sum+w[i]);
            F[++tot]=k; ///继续记录访问时间戳，那么此时就相当于在每个子节点中插入了父节点，
                        ///在利用pos下标查询RMQ时父节点的信息就卡在了两者之间
            rmq[tot]=d;
        }
    }
}

ST(来源 ：kuangbin模板): 

int F[maxn],pos[maxn],tot;
long long cost[maxn];

int rmq[maxn];//rmq数组，就是欧拉序列对应的深度序列
struct ST
{
    int mm[2*maxn];
    int dp[2*maxn][20];//最小值对应的下标
    void init(int n)
    {
        mm[0] = -1;
        for(int i = 1; i <= n; i++)
        {
            mm[i] = ((i&(i-1)) == 0)?mm[i-1]+1:mm[i-1];
            dp[i][0] = i;
        }
        for(int j = 1; j <= mm[n]; j++)
            for(int i = 1; i + (1<<j) - 1 <= n; i++)
                dp[i][j] = rmq[dp[i][j-1]] < rmq[dp[i+(1<<(j-1))][j-1]]?dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
    }
    int query(int a,int b)//查询[a,b]之间最小值的下标
    {
        if(a > b)swap(a,b);
        int k = mm[b-a+1];
        return rmq[dp[a][k]] <= rmq[dp[b-(1<<k)+1][k]]?dp[a][k]:dp[b-(1<<k)+1][k];
    }
} st;

初始化：

void LCA_init()
{
    memset(vis,0,sizeof vis);
    for(int i=1; i<=n; i++)
    {
        if(!vis[i])
        {
            dfs(i,1,0);
        }
    }
    st.init(tot);
}


查询部分：

long long Query(int s,int t)
{
    int lca=F[ st.query(pos[s],pos[t]) ];
    return cost[s]+cost[t]-2*cost[lca];
}

HDU 2586  How far away ？


#include<cstring>
#include<string>
#include<iostream>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<map>
#include<cstdlib>
#include<cmath>
#include<vector>
//#pragma comment(linker, "/STACK:1024000000,1024000000");

using namespace std;

#define INF 0x3f3f3f3f
#define maxn 80004

int fir[maxn],nex[maxn],v[maxn],w[maxn],e_max;
int pos[2*maxn],T[2*maxn],tot;
long long cost[maxn];
int rmq[2*maxn];//rmq数组，就是欧拉序列对应的深度序列
struct ST
{
    int mm[2*maxn];
    int dp[2*maxn][20];//最小值对应的下标
    void init(int n)
    {
        mm[0] = -1;
        for(int i = 1; i <= n; i++)
        {
            mm[i] = ((i&(i-1)) == 0)?mm[i-1]+1:mm[i-1];
            dp[i][0] = i;
        }
        for(int j = 1; j <= mm[n]; j++)
            for(int i = 1; i + (1<<j) - 1 <= n; i++)
                dp[i][j] = rmq[dp[i][j-1]] < rmq[dp[i+(1<<(j-1))][j-1]]?dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
    }
    int query(int a,int b)//查询[a,b]之间最小值的下标
    {
        if(a > b)swap(a,b);
        int k = mm[b-a+1];
        return rmq[dp[a][k]] <= rmq[dp[b-(1<<k)+1][k]]?dp[a][k]:dp[b-(1<<k)+1][k];
    }
}LCA;

void init()
{
    memset(fir,-1,sizeof fir);
    e_max=0;
    tot=1;
}

void add_edge(int s,int t,int c)
{
    int e=e_max++;
    v[e]=t;
    w[e]=c;
    nex[e]=fir[s];
    fir[s]=e;
}

void dfs(int k,int pre,int d,long long sum)
{
    cost[k]=sum;
    pos[k]=tot;
    T[tot]=k;
    rmq[tot++]=d;
    for(int i=fir[k]; ~i; i=nex[i])
    {
        int e=v[i];
        if(e==pre) continue;
        dfs(e,k,d+1,sum+w[i]);
        T[tot]=k;
        rmq[tot++]=d;
    }
}

void LCA_init()
{
    dfs(1,-1,1,0);
    LCA.init(tot-1);
}

long long Query(int s,int t)
{
    int lca=T[LCA.query(pos[s],pos[t])];
    return cost[s]+cost[t]-2*cost[lca];
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        init();
        int n,m;
        scanf("%d%d",&n,&m);
        for(int i=1; i<n; i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
            add_edge(b,a,c);
        }
        LCA_init();
        while(m--)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            long long ans=Query(l,r);
            printf("%lld\n",ans);
        }
    }
    return 0;
}

POJ 1986 Distance Queries

#include<cstring>
#include<string>
#include<iostream>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<map>
#include<cstdlib>
#include<cmath>
#include<vector>
//#pragma comment(linker, "/STACK:1024000000,1024000000");

using namespace std;

#define INF 0x3f3f3f3f
#define maxn 80004

int x[maxn],y[maxn],c[maxn],e[maxn],s[maxn],pos[2*maxn];
int fir[maxn],nex[maxn],v[maxn],w[maxn],e_max,tot;
long long cost[maxn];

int rmq[2*maxn],F[2*maxn];//rmq数组，就是欧拉序列对应的深度序列
struct ST
{
    int mm[2*maxn];
    int dp[2*maxn][20];//最小值对应的下标
    void init(int n)
    {
        mm[0] = -1;
        for(int i = 1; i <= n; i++)
        {
            mm[i] = ((i&(i-1)) == 0)?mm[i-1]+1:mm[i-1];
            dp[i][0] = i;
        }
        for(int j = 1; j <= mm[n]; j++)
            for(int i = 1; i + (1<<j) - 1 <= n; i++)
                dp[i][j] = rmq[dp[i][j-1]] < rmq[dp[i+(1<<(j-1))][j-1]]?dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
    }
    int query(int a,int b)//查询[a,b]之间最小值的下标
    {
        if(a > b) swap(a,b);
        int k = mm[b-a+1];
        return rmq[dp[a][k]] <= rmq[dp[b-(1<<k)+1][k]]?dp[a][k]:dp[b-(1<<k)+1][k];
    }
} LCA;

void init()
{
    memset(fir,-1,sizeof fir);
    e_max=0;
    tot=1;
}

void add_edge(int s,int t,int c)
{
    int e=e_max++;
    v[e]=t;
    w[e]=c;
    nex[e]=fir[s];
    fir[s]=e;
}

void dfs(int k,int pre,int d,long long sum)
{
    pos[k]=tot;
    rmq[tot]=d;
    F[tot++]=k;
    cost[k]=sum;
    for(int i=fir[k]; ~i; i=nex[i])
    {
        int e=v[i];
        if(e!=pre)
        {
            dfs(e,k,d+1,sum+w[i]);
            rmq[tot]=d;
            F[tot++]=k;
        }
    }
}

void LCA_init()
{
    dfs(1,-1,1,0);
    LCA.init(tot-1);
}

long long Query(int s,int t)
{
    int lca=F[LCA.query(pos[s],pos[t])];
    return cost[s]+cost[t]-2*cost[lca];
}

bool cmp(int a,int b)
{
    return c[a]<c[b];
}

int root(int x)
{
    return s[x]==x?x:s[x]=root(s[x]);
}

int n,m;
void build()
{
    for(int i=0; i<=n; i++) s[i]=i;
    sort(e+1,e+m+1,cmp);
    for(int i=1; i<=m; i++)
    {
        int r=e[i];
        int _x=root(x[r]);
        int _y=root(y[r]);
        if(_x!=_y)
        {
            s[_x]=_y;
            add_edge(x[r],y[r],c[r]);
            add_edge(y[r],x[r],c[r]);
        }
    }
}

int main()
{

    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        for(int i=1; i<=m; i++)
        {
            char str[5];
            scanf("%d%d%d%s",&x[i],&y[i],&c[i],str);
            e[i]=i;
        }
        build();
        LCA_init();
        int q;
        scanf("%d",&q);
        while(q--)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            printf("%lld\n",Query(l,r));
        }
    }
    return 0;
}


HDU 2874 Connections between cities


#include<cstring>
#include<string>
#include<iostream>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<map>
#include<cstdlib>
#include<cmath>
#include<vector>
//#pragma comment(linker, "/STACK:1024000000,1024000000");

using namespace std;

#define INF 0x3f3f3f3f
#define maxn 40004

int x[maxn],y[maxn],c[maxn],e[maxn];
int vis[maxn];
int fir[maxn],nex[maxn],v[maxn],w[maxn],e_max,s[maxn];
int F[maxn],pos[maxn],tot;
long long cost[maxn];

int rmq[maxn];//rmq数组，就是欧拉序列对应的深度序列
struct ST
{
    int mm[2*maxn];
    int dp[2*maxn][20];//最小值对应的下标
    void init(int n)
    {
        mm[0] = -1;
        for(int i = 1; i <= n; i++)
        {
            mm[i] = ((i&(i-1)) == 0)?mm[i-1]+1:mm[i-1];
            dp[i][0] = i;
        }
        for(int j = 1; j <= mm[n]; j++)
            for(int i = 1; i + (1<<j) - 1 <= n; i++)
                dp[i][j] = rmq[dp[i][j-1]] < rmq[dp[i+(1<<(j-1))][j-1]]?dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
    }
    int query(int a,int b)//查询[a,b]之间最小值的下标
    {
        if(a > b)swap(a,b);
        int k = mm[b-a+1];
        return rmq[dp[a][k]] <= rmq[dp[b-(1<<k)+1][k]]?dp[a][k]:dp[b-(1<<k)+1][k];
    }
} st;

void init()
{
    e_max=0;
    tot=0;
    memset(fir,-1,sizeof fir);
}

void add_edge(int s,int t,int c)
{
    int e=e_max++;
    v[e]=t;
    w[e]=c;
    nex[e]=fir[s];
    fir[s]=e;
}

bool cmp(int a,int b)
{
    return c[a]<c[b];
}

int root(int x)
{
    return s[x]==x?x:s[x]=root(s[x]);
}

int n,m,q;
void build()
{
    sort(e,e+m,cmp);
    for(int i=0; i<=n; i++) s[i]=i;
    for(int i=0; i<m; i++)
    {
        int r=e[i];
        int _x=root(x[r]);
        int _y=root(y[r]);
        if(_x!=_y)
        {
            s[_x]=_y;
            add_edge(x[r],y[r],c[r]);
            add_edge(y[r],x[r],c[r]);
        }
    }
}

void dfs(int k,int d,long long sum)
{
    cost[k]=sum;
    pos[k]=++tot;
    F[tot]=k;
    rmq[tot]=d;
    vis[k]=1;
    for(int i=fir[k];~i;i=nex[i])
    {
        int e=v[i];
        if(!vis[e])
        {
            dfs(e,d+1,sum+w[i]);
            F[++tot]=k;
            rmq[tot]=d;
        }
    }
}

void LCA_init()
{
    memset(vis,0,sizeof vis);
    for(int i=1; i<=n; i++)
    {
        if(!vis[i])
        {
            dfs(i,1,0);
        }
    }
    st.init(tot);
}

long long Query(int s,int t)
{
    int lca=F[ st.query(pos[s],pos[t]) ];
    return cost[s]+cost[t]-2*cost[lca];
}
int main()
{

    while(scanf("%d%d%d",&n,&m,&q)!=EOF)
    {
        init();
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&x[i],&y[i],&c[i]);
            e[i]=i;
        }
        build();
        LCA_init();
        while(q--)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            if(root(l)!=root(r))
                printf("Not connected\n");
            else  printf("%lld\n",Query(l,r));
        }
    }
    return 0;
}

wJs9528-1
关注
专栏目录
LCA 与 RMQ
Balloons2012的专栏
08-26 1918
求LCA可以用tarjan算法（见代码); 这里不详细介绍了。用到的东西主要是dfs + 并查集。 详见最下面的代码。 还有一种方法是利用 倍增的思想 求。 具体就是：    f[i][j] 表示i的第2^j次方个祖先是谁。 则f[i][j]= f[ f[i][j-1] ][j-1]; (j>0)        f[i][j]=father[i];(j==0)   这样可以处理出每个节点的
LCA转RMQ 模版及解析 + LCA倍增法模版
九野的博客
11-11 5517
九野的博客，转载请注明出处：http://blog.csdn.net/acmmmm/article/details/15490519   LCA:  最近公共祖先 则 LCA(2,3) = 2 ; LCA(3,4) = 5; LCA(1,2) = 5; LCA(1,5) = 5;   RMQ: 区间最值问题, 给定一组数，在O(logn) 的复杂度内回答区间的最值 （一般采用线段树
LCA && RMQ模版
晚晴小筑
06-06 97
RMQ（space table算法） /* RMQ(Range Minimum/Maximum Query)问题： RMQ问题是求给定区间中的最值问题。当然，最简单的算法是O(n)的，但是对于查询次数很多（设置多大100万次），O(n)的算法效率不够。可以用线段树将算法优化到O（logn)（在线段树中保存线段的最值）。不过，Sparse_Table算法才是最好的：它可以在O(nlogn...
LCA转RMQ模板
yxmGo
03-12 186
int head[maxn]; int first[maxn];//首次出现的下标 int dp[maxn*2][30]; bool vis[maxn]; bool ok[maxn]; int deep[maxn*2];//深度数组 int ver[maxn*2];//节点序列 int n,cnt,tot; struct Edge{ int next; int to; }edge[...
Lca与Rmq
08-22 102
关于LCA和RMQ问题 一、最近公共祖先(Least Common Ancestors) 对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能大。另一种理解方式是把T理解为一个无向无环图，而LCA(T,u,v)即u到v的最短路上深度最小的点。 这里给出一个LCA的例子： 例一 对于T=<V,E>V={1,...
LCA 转 RMQ算法 【总结】
世界很大
08-08 4410
首先，在你看这个算法之前，要确保你理解了RMQ的 ST 算法。 但是不理解没关系啊，提供通道：  点我 声明：这是方便我以后复习用的，所以总结不是特别详细。 LCA - 最近公共祖先：在有根树中，两个节点u和v的公共祖先中距离最近的那个点。 上图理解： 如图，我们想要求出LCA（4，7），LCA（8，6），LCA（5，8）。 用LCA转R
洛谷 P3379 【模板】最近公共祖先（LCA）
最新发布
qq_17807067的博客
11-08 268
P3379 【模板】最近公共祖先（LCA），用线段树和倍增求解！
我的所有优质博客全部开源啦（我自己原创的《ACM模板》《算法全家桶》《算法竞赛中的初等数论》 PDF免费下载）
热门推荐
繁凡さん的博客
11-13 1万+
你好呀ヾ(≧▽≦*)o 我是繁凡さん
牛客算法竞赛入门笔记6
m0_58178876的博客
04-25 509
RMQ与LCA 这章真的是题目难，代码量还大，动不动就快200行了，呜呜呜。 LCA: 树上问题通过dfs序转化成区间问题（一般都是dfn序） P3379 【模板】最近公共祖先（LCA） - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 题意：LCA模板题 第一种做法：dfs序将LCA问题转换为RMQ问题，我们先用dfn序给每个结点标上序号，再用dfs求出树的欧拉序列，然后保存下每个数第一次出现在欧拉序列中的位置，两个数的LCA即为..
ACM比赛经验、刷题记录及模板库总结（更新中）
lordofadventure的博客
03-08 1836
文章目录前言第一部分 经验分享及感受第二部分 刷题记录一、基础算法&程序语言二、综合题（现场题）三、动态规划四、图论五、字符串算法六、数据结构七、数学八、网络流九、博弈十、随机算法十一、其他第三部分 专项题库第四部分 模板库附录A 题目索引附录B 常用平台参考文献 前言 本文所提及的部分题目代码，可以在https://github.com/volactina/ACM上找到 第一部分 经验分...
RMQ-ST 解决在线LCA
一地鸡毛
10-25 934
#include #include #include #include using namespace std; int L=0, R=999999; int t[1000000]; int s[1000000]; int m[1000000]; // idx of node with min depth in sort-vq[] int d[1000000];
RMQ-LCA模板
ACTerminate的博客
09-16 333
#include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;vector&gt; #include &lt;queue&gt; #include &lt;set&gt; #include &
hihoCoder #1069 最近公共祖先·三
weixin_30455023的博客
12-11 118
#1069 : 最近公共祖先·三 Time Limit:10000ms Case Time Limit:1000ms Memory Limit:256MB 描述 上上回说到，小Hi和小Ho使用了Tarjan算法来优化了他们的“最近公共祖先”网站，但是很快这样一个离线算法就出现了问题：如果只有一个人提出了询问，那么小Hi和小Ho很难决定到底是针对这个询...
RMQ求LCA【ST】算法
Wyt_code的博客
11-09 904
RMQ求LCA其实非常简单的啦 我们需要理解两个基本的工具： 1.欧拉序列； 2.线段树，二叉搜索树或者其它基本区间寻求最值的方法； 所以说LCA和区间有什么关系？ 举个栗子： 我们将欧拉序列E打出： 【1,2,4,2,5,2,1,3,6,3,1】（先自己想想怎么实现） 在打印序列的同时记录下每个节点第一次出现的位置R 【1,2,8,3,5,9】 另外别忘了给欧拉序列标深度...
RMQ转LCA
九野的博客
11-11 1740
数组里的最小值做根 左边的数在左子树 右边的数在右子树 递归建成整棵树 就从rmq转成lca了 左右的数 是数组中 相对父节点 下标   比如对数组 7 5 8 1 10 建出的树是这样的
LCA问题（含RMQ的ST算法）
新的开始...
10-21 610
一、定义与定理       LCA：Least Common Ancestors（最近公共祖先），对于一棵有根树T的任意两个节点u，v，求出LCA(T, u, v)，即离跟最远的节点x，使得x同时是u和v的祖先。       在线算法：用比较长的时间做预处理，但是等信息充足以后每次回答询问只需要用比较少的时间。       离线算法：先把所有的询问读入，然后一起把所有询问回答完成。    
LCA RMQ算法模板
mhd2312的博客
08-12 171
题目：HDU 3078 Network 主要贴一下LCA RMQ的算法模板，供以后回忆 #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstdlib&gt; #include &lt;algorithm&gt; #include &lt;cstring&gt; #include &lt;cmath&gt; #in...
LCA和RMQ算法
wa的一声就哭了
11-01 347
RMQ（Range Minimum/Maximum Query），即区间最值查询，是指这样一个问题：对于长度为n的数列A，回答若干次询问RMQ(i,j)，返回数列A中下标在区间[i,j]中的最小/大值。 本文介绍一种比较高效的ST算法解决这个问题。ST（Sparse Table）算法可以在O(nlogn)时间内进行预处理，然后在O(1)时间内回答每个查询。 1）预处理 设A[i]是要求...
RMQ与LCA问题：算法解析与应用
值得注意的是，RMQ和LCA问题可以通过某种转换互相转化，这意味着上述算法的应用场景可以得到扩展。这样的转化能力使得解决一个问题的方法可能适用于另一个问题，从而提高了算法的实用性。 RMQ和LCA问题在算法设计和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值