【在线lca 模板】LCA 练习题2 ： hdu 3078 + poj2763 我要记一辈子的s b错误

最新推荐文章于 2022-07-15 22:16:27 发布
最新推荐文章于 2022-07-15 22:16:27 发布
阅读量651 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24664053/article/details/51425256
版权

poj 2763 ： 真的好傻逼的错误。
先讲题意：
先刷入 n q cur；
然后输入 n-1 条边，构成一棵树
然后q 行，每行一个操作： op 若op = 1,则输入 pos，w , 代表将上面的第pos条边的权值修改为w；
若op=0， 输入to，则代表将cur 移动到to这个位置，并输出最短的距离。

有人说是很标准的树链剖分， 但这题用lca 也能做一做。时间复杂度有点糟TUT
其实询问就是普通的lca 查询。
但是更新会有点麻烦。 其实并不复杂。
要修改第i 条边，则 tot =2*i 和2 * i+1。 修改完之后要怎么更新呢？？？
仔细想想，其实我们最朴素的想法就可以实现：我们直接往更深的地方更新dir即可。 因为dir 存的是到root的距离，然后我们把改变的边的终点找出来，往下更新即可，但是更新的时候呢，只能往下，也就是只能往rmq更大的节点更新。 ！！！！！！！！！！错误来了，对于节点i 的深度我居然特么写成了 rmq[i]，真的好蠢啊，rmq长度为2*MAXN，兄弟，rmq 对应的是F ，怎么能直接就写成rmq[i]啊，我真是醉了，完了自己debug了一下午+一晚上。 i的深度肯定得写成 rmq[first[i]]。 

#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
#include <stack>
typedef long long ll;
using namespace std;

const int MAXN=100010;
int rmq[2*MAXN]; //rmq数组, 记录每个节点在树中的深度
struct ST{
    int mm[2*MAXN];
    int dp[2*MAXN][20]; //dp 直接存下标
    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; //初始化dp数组
        }
        for(int j=1;j<=mm[n];j++)   //可以看出来mm[n] 就是一个长度为n的序列j的最大值
            for(int i=1;i+(1<<j)-1 <=n ; i++){
                if(rmq[dp[i][j-1]] < rmq[dp[i+(1<<(j-1))][j-1] ]){
                    dp[i][j]=dp[i][j-1];
                }
                else
                    dp[i][j]=dp[i+(1<<(j-1))][j-1];
            }
    }
    int query(int a,int b){  //这个询问返回的是位置pos， F[pos]才是值
            if(a>b)
                swap(a,b);
            int k=mm[b-a+1];
            if(rmq[dp[a][k]] <= rmq[dp[b-(1<<k)+1][k]] ){
                return dp[a][k];
            }
            else
                return dp[b-(1<<k)+1][k];
    }
};
struct Edge{
    int to,next;
    int w; // 用w来记录权值：即到根部的距离。
};
Edge edge[MAXN*2];
int tot,head[MAXN];
int F[MAXN*2];   // 按顺序存储节点 ，下标从1开始,长度为2*n-1
int first[MAXN]; // i在F中第一次出现的位置
int cnt;
int fa[MAXN];  //  记录每个点的父亲节点，以此来找路径会特别方便
int w[MAXN];
int dir[MAXN];
ST st;

void addedge(int u,int v,int w){ //无向边自然加两次
    edge[tot].to=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void dfs(int u,int pre,int dep){ //u起点，dep表示深度
     F[++cnt] = u;    // cnt就是这个节点的下标
     fa[u]=pre;
     rmq[cnt]=dep;    //rmq记录节点在树中的深度
//     printf("dfs:%d %d %d %d\n",u,dep,rmq[c],pre);
     first[u]=cnt;       //这个first 不会被更新掉,因为我们把continue了回去的路
     for(int i=head[u];i!=-1; i=edge[i].next){
         int v=edge[i].to;
         if(v==pre) continue;

       dir[v]=dir[u] + edge[i].w;
         dfs(v,u,dep+1);
         F[++cnt] = u;     //虽然continue回去的路，但是询问叶子节点还要返回：1-2-1 --....
         rmq[cnt] = dep;
     }
}
void LCA_init(int root ,int node_num){ //查询LCA前的初始化
    cnt=0;
    dfs(root,root,0);
    st.init(2*node_num-1); // 注意 ，这里dp的不是n，而是对F进行dp
}
int query_lca(int u,int v){   //查询lca(u,v)
    return F[st.query(first[u],first[v])];
}

bool flag[MAXN];
void work(int u,int pre,int cnt){
    dir[u]+=cnt;
    for(int i=head[u];i!=-1; i=edge[i].next){
             int v=edge[i].to;
             if(v==pre) continue;
             if(rmq[first[u] ]<rmq[first[v]])
                 work(v,u,cnt);
    }
}
void init(){
    tot=0;
    memset(head,-1,sizeof(head));
    memset(flag,0,sizeof(flag));
//  memset(rmq,0,sizeof(rmq));
}
int main(){
    //freopen("1.txt","r",stdin);
    int n,q,cur;
    while(~scanf("%d %d %d",&n,&q,&cur)){
        init();
        for(int i=1;i<n;i++){
            int a,b,c;
            scanf("%d %d %d",&a,&b,&c);
            addedge(a,b,c);  // 第i条边  为edge[(i-1)*2]  和edge[(i-1)*2+1]
            addedge(b,a,c);
            flag[b]=true;
        }
        int root;
                for(int i=1;i<=n;i++)
                    if(!flag[i]){ //某个根
                        root=i;
                        break;
                    }
//              mem()
        dir[root]=0;
//      printf("root=%d\n",root);
        LCA_init(root,n);

        while(q--){
            int op;
            scanf("%d",&op);
            if(op==0){
                int to;
                scanf("%d",&to);
                int end=query_lca(cur,to);
                __int64 ans=0;
//              printf("%d %d %d\n",dir[cur],dir[to],dir[end]);
                ans=(__int64)dir[cur]+dir[to]-2*dir[end];
                cur=to;
                 printf("%I64d\n",ans);
            }
            else {
                int i,tem;
                scanf("%d %d",&i,&tem);
                int change=tem-edge[(i-1)*2].w;
                edge[(i-1)*2].w=edge[ ((i-1)*2)+1 ].w=tem;
                int u=edge[(i-1)*2].to,v=edge[(i-1)*2+1].to;

//              printf("u,v:%d %d %d %d\n",u,v,rmq[first[u]],rmq[first[v]]);
                if(rmq[first[u]]<rmq[first[v]]) swap(u,v);
                work(u,v,change);
                //我们用dir 记录到根节点的距离 ，所以往深度大的节点改动就行了，深度小的本身就不改变
            }
        }
    }
    return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=3078
题意：
给一个n,q
然后给出n个节点的权值
接下来n-1 行，每行给一条无向边连接两个节点。
然后q行
每行一个操作：
输入 三个数 a,b,c 若a=0 ，则将点b 的权值改为c
若a！=0 ，则操作是询问 从 b -c 路径上所有点的权值 第K大是多少

首先得明确一个观点：
这种题目 操作中加入了修改，所以你修改会影响到下面的询问，讲道理会用在线算法。

对于这个题：我一开始想用一个 set去存每一个节点到根节点的路径。 因为N=8W ，二维数组开不下来。 但是set 不可以放重复的元素。 然后我就卡住了。 想了半天觉得 不可能说用一个东西来存路径，因为内存必然不够。
但是我们只要知道路径，在线的提取出来不就好了吗？

我们可以多开一个数组pre， pre[i]就代表 i的上一个节点是多少， 当我们建好树之后， 如果询问 i 和 j的路径第K大的节点。我们就可以 k= lca(i,j)
然后我们吧 i ->k 和 j->k 路径上的点的权值都记录在数组里，就可以找到第k大点了

#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
#include <stack>
typedef long long ll;
using namespace std;

const int MAXN=80010;
int rmq[2*MAXN]; //rmq数组, 记录每个节点在树中的深度
struct ST{
    int mm[2*MAXN];
    int dp[2*MAXN][20]; //dp 直接存下标
    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; //初始化dp数组
        }
        for(int j=1;j<=mm[n];j++)   //可以看出来mm[n] 就是一个长度为n的序列j的最大值
            for(int i=1;i+(1<<j)-1 <=n ; i++){
                if(rmq[dp[i][j-1]] < rmq[dp[i+(1<<(j-1))][j-1] ]){
                    dp[i][j]=dp[i][j-1];
                }
                else
                    dp[i][j]=dp[i+(1<<(j-1))][j-1];
            }
    }
    int query(int a,int b){  //这个询问返回的是位置pos， F[pos]才是值
            if(a>b)
                swap(a,b);
            int k=mm[b-a+1];
            if(rmq[dp[a][k]] <= rmq[dp[b-(1<<k)+1][k]] ){
                return dp[a][k];
            }
            else
                return dp[b-(1<<k)+1][k];
    }
};
struct Edge{
    int to,next;
    int w; // 用w来记录权值：即到根部的距离。
};
Edge edge[MAXN*2];
int tot,head[MAXN];
int F[MAXN*2];   // 按顺序存储节点 ，下标从1开始,长度为2*n-1
int first[MAXN]; // i在F中第一次出现的位置
int cnt;
int fa[MAXN];  //  记录每个点的父亲节点，以此来找路径会特别方便
int w[MAXN];
ST st;
void init(){
    tot=0;
    memset(head,-1,sizeof(head));

}
void addedge(int u,int v){ //无向边自然加两次
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void dfs(int u,int pre,int dep){ //u起点，dep表示深度
     F[++cnt] = u;    // cnt就是这个节点的下标
     fa[u]=pre;
     rmq[cnt]=dep;    //rmq记录节点在树中的深度
     first[u]=cnt;       //这个first 不会被更新掉,因为我们把continue了回去的路
     for(int i=head[u];i!=-1; i=edge[i].next){
         int v=edge[i].to;
         if(v==pre) continue;

//       dir[v]=dir[u] + edge[i].w;
         dfs(v,u,dep+1);
         F[++cnt] = u;     //虽然continue回去的路，但是询问叶子节点还要返回：1-2-1 --....
         rmq[cnt] = dep;
     }
}
void LCA_init(int root ,int node_num){ //查询LCA前的初始化
    cnt=0;
    dfs(root,root,0);
    st.init(2*node_num-1); // 注意 ，这里dp的不是n，而是对F进行dp
}
int query_lca(int u,int v){   //查询lca(u,v)
    return F[st.query(first[u],first[v])];
}
bool flag[MAXN];
int main(){
  //  freopen("1.txt","r",stdin);
    int n,q;
    while(~scanf("%d %d",&n,&q)){
        init();
        memset(flag,0,sizeof(flag));
        for(int i=1;i<=n;i++)
            scanf("%d",&w[i]);
        for(int i=1;i<n;i++){
            int u,v;
            scanf("%d %d",&u,&v);
            addedge(u,v);
            addedge(v,u);
            flag[v]=1;
        }
        int root;
        for(int i=1;i<=n;i++)
                    if(!flag[i]){ //某个根
                        root=i;
                        break;
                    }
        LCA_init(root,n);
        int ans[MAXN];
        while(q--){
            int f,a,b;
            scanf("%d %d %d",&f,&a,&b);
            if(f==0){
                w[a]=b;
                continue;
            }
            int u=a;
            int v=b;
            int end=query_lca(u,v);
            int len=0;
            while(u!=end){
//              printf("fa=%d %d %d\n",fa[u],w[u],w[fa[u]]);
                ans[len++]=w[u];
                u=fa[u];
            }
            while(v!=end){
                ans[len++]=w[v];
                v=fa[v];
            }
            ans[len++]=w[end];
            sort(ans,ans+len);
//          printf("ans:");
//          for(int i=0;i<len;i++)
//              printf("%d ",ans[i]);
//          cout<<endl;
            if(f>len)
                printf("invalid request!\n");
            else
                printf("%d\n",ans[len-f]);
        }

    }
    return 0;
}
yuhaoyuan……
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LCA模板题
rain_falls
02-24 653
LCA
Hdoj 2586 How far away ？ 【LCA】
shengweisong
04-14 1019
How far away ？ Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 7072 Accepted Submission(s): 2575Problem DescriptionThere are n houses in th
p3379——LCA模版题
qq_45775524的博客
06-13 145
题目链接 #include<bits/stdc++.h> using namespace std; //LCA（Least Common Ancestors），即最近公共祖先，是这样一个问题： 在有根树中，找出某两个结点 u和 v最近的公共祖先（或者说，离树根最远的公共祖先）。 //倍增解法 倍增解法的核心是分治思想。 //当已知两个点在树中的深度时，先让较深的结点向上走，直到两个结点深度一样；再二分找出离他们最近的公共祖先。 //我们记一个结点的父结点为它的 2^0=1 倍祖先，它的父结点的父
LCA问题专题
R的博客
07-15 427
LCA的于各类题目中的应用
LCA题集
自强不息 厚德载物
10-02 425
点的距离（模板题） 树中两点间的距离就是d[u] + d[v] - 2 * d[lca(u, v)] #include&lt;bits/stdc++.h&gt; #define REP(i, a, b) for(register int i = (a); i &lt; (b); i++) #define _for(i, a, b) for(register int i = (a); i &...
【POJ1330】最近公共祖先（LCA）：并查集+深搜 - cxllyg的专栏 - 博客频道 - CSDN.NET1
最新发布
08-03
【最近公共祖先（LCA）问题详解】 最近公共祖先（Lowest Common Ancestor，简称LCA）是指在一颗树中，两个指定节点的最近的共同祖先。这个问题在计算机科学，尤其是数据结构和算法领域中非常常见，特别是在处理...
lca2015-radare2-tutorial:我的 LCA2015radare2 教程的示例和演示
07-01
LCA2015 Radare2 教程注意事项先决条件最低要求是构建radare2 所需的C 编译器和库，以及用于查看调用图的xdot。 各种其他工具可能会有所帮助，并且确实需要完成练习的所有部分如果您使用的是 Debian 派生的发行版，...
分析:架构云存储的TCS和LCA两大架构
11-10
对于一个成功的、具有极高可扩展性的NAS存储系统来说，要想架构云存储系统解决方案需要什么? 　云存储的概念始于Amazon提供的一项服务，同时还伴随着其云计算产品。在Amazon的S3的服务背后，它还管理着多个商品硬件...
linux-conf-au-2019-epaper-badge：lca2019的我的IoT徽章
02-05
【标题】"Linux Conf AU 2019 E-Paper Badge: LCA2019的IoT徽章"是一个项目，它展示了在Linux Conf AU 2019（一个年度Linux和技术会议）上使用的物联网(IoT)电子纸显示徽章。这个徽章不仅是一个标识符，更是一个小型...
lca-rmq:RMQ查找LCA的算法的实现
05-15
最小公祖问题的算法。 如“重新审阅LCA问题”中所述，这将使用...levels : [1, 2, 3, 2, 3, 2, 1, 2, 3, 2, 3, 2, 1] ------ query distance --> | | starting index V 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 12,
LCA 离线算法 tarjan 总结 与模板题
liujc_的专栏
03-13 1868
LCA问题为最近公共祖先问题，常见的有一种在线的算法和一种离线的算法。这里介绍一下离线的tarjan算法。 离线算法需要首先读入所有的查询，然后重新组织对查询处理的顺序来达到更高效的处理。 tarjan算法使用的是dfs + 并查集的思想。 算法描述： 对于每一个dfs到的节点，就需要在并查集中创建一个以这个节点为独立的集合，然后继续dfs子树，当搜索完子树的时候，也就将与这个子树内的LCA
|poj 2763|LCA, 树状数组|或者|树链剖分, 线段树|Housewife Wind
博客停更，请到"再见，CSDN"文章中找新博客地址
05-09 598
poj 2763LCA+树状数组/线段树。首先本题大致一看就是一个LCA，但是本题有操作更改某边的权，这样会使得原本的far数组变化，不难发现，更改边权后影响该边下面所有点的答案。此时可以在LCA的DFS预处理时求出DFS序列(即时间戳)，找到每个点管辖的范围，修改边权相当于修改该边连接的两个点深度深的那个点所管辖的范围，此时修改可以用暴力，但是由于far数组与LCA本身查询无关，我们可以用数据结构
HDU 5770 Treasure（在线倍增LCA+扫描线+线段树）
ZSQ
08-10 830
Description 给定一棵有n个节点的树，有m个宝箱和对应的钥匙，它们可能在不同的节点上，也可能在相同的节点上，每个宝箱都有对应的权值(可为负数)，现要求在树上选一条简单路径，每到一个节点时，必须先拿走该节点所有的钥匙，然后开启该节点所有能开启的宝箱，求能得到的最大权值和 Input 第一行一整数T表示用例组数，每组用例首先输入两个整数n和m分别表示点数和宝箱数，之后n-1行每行两个整数
lca 在线模板讲解
DK
10-18 258
参考 http://blog.csdn.net/y990041769/article/details/40887469 首先搞清楚离线和在线做法的区别。 在线的做法是处理每一次询问，得出答案。 在线用到了st+dfs 这个模板是从大佬那里copy过来的，加上自己的理解，姑且算是原创吧。#include <iostream> #include <cstdio> #include <cstrin
HDU - 6031 (lca) (暴力剪枝 或者 二分）
DS00HY的小博客
05-17 236
Innumerable Ancestors HDU - 6031 ...
HDU 5452 LCA
Dan__ge的博客
05-25 3322
点击打开链接 题意：给一个树和树上的分支组成的图，问我当且仅当删除一条树上的边，最少再删除几条边使得图不连通 思路：我写了两个做法，第一种是不加优化的十分暴力的LCA，也就是裸的，因为这道题目的数据说很水，这样的复杂度也可以，O(n*m)，n为20000，m为200000，明明是超时好不好，这个做法也简单易懂，在这个树上，我们加了一条边u->v，那么u与v的最近公共祖先为fa，那么u->f
LCA & 用到LCA的各种题目
qq_35811331的博客
08-22 747
LCA求最近公共祖先LCA LCA 倍增实现快速求出树上两点的公共祖先，实现原理像是树上ST表，先预处理出来每个点的2^n的父亲是谁与它的深度，然后求lca时把两点先都跳到同一高度，如果重合为一个点，则这个点就是最近公共祖先，不然就倍增从大到小跳，直到跳到祖先的儿子节点，然后返回此时节点的父亲节点。 代码： #include <bits/stdc++.h> using namespac...
【题解】LNOI-2014 LCA 好题
测试运算符
06-04 291
Problem 洛谷 &amp; bzoj 题目概要（题目不完整，细节看链接）： 给出有根树，设dep[i]dep[i]dep[i]表示点iii的深度，有q次询问，每次询问给出l,r,zl,r,zl,r,z，求∑ri=ldep[lca(i,z)]∑i=lrdep[lca(i,z)]\sum_{i=l}^rdep[lca(i,z)] Thoughts 感觉可以从下网上动态加边，并预处理...
HDU - 2586 LCA入门
wuyin_Jane的博客
08-21 203
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”? Usual...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值