树上倍增的应用

最新推荐文章于 2022-07-18 15:50:08 发布
最新推荐文章于 2022-07-18 15:50:08 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： 倍增算法 文章标签： 树上倍增 lca CF 980 E 树上差分 区间lca
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38786088/article/details/82261484
版权

树上倍增的应用

归根到底，树上倍增的应用就是求LCA

RMQ + 树上深搜

int fa[N][20];
int toUsed = 1;
struct node{
    int to;
    int nxt;
}p[N*2];
void mkedge(int u,int v){
    p[toUsed].to = v;
    p[toUsed].nxt = head[u];
    head[u] = toUsed++;

    p[toUsed].to = u;
    p[toUsed].nxt = head[v];
    head[v] = toUsed++;
}

void mkTree(int rt,int pre){
    fa[rt][0] = pre;
    dep[rt] = dep[pre] + 1;
    for(int i=1;i<20;++i)
        fa[rt][i] = fa[fa[rt][i-1]][i-1];
    for(int i=head[rt];i!=-1;i=p[i].nxt){
        int sn = p[i].to;
        if(sn==pre) continue;
        mkTree(sn,rt);
    }
}

一、树上差分

树上差分： 就是在大量修改点对之间路径上边的权值(路径修改，同加），修改两个端点的lca的向上边-2*val，u，v两点向上边+val，找lca，RMQ记录祖先ST表

EOJ 3631
题意： n次路径修改，有m-1个值将要赋给 m-1条树边，问赋值后使得每条边的修改次数*边权之和最小，求最小值。

树上差分得到所有边的修改次数，将权值和修改次数排序，也就是修改次数最多的边匹配最小权值！加了一点贪心思维！

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <set>
#include <map>
#include <algorithm>
#include <string.h>
#define llt long long
using namespace std;

const int N = 2e5+777;
int w[N],head[N],val[N],dep[N];
int fa[N][20];
int toUsed = 1;
struct node{
    int to;
    int nxt;
}p[N*2];
void mkedge(int u,int v){
    p[toUsed].to = v;
    p[toUsed].nxt = head[u];
    head[u] = toUsed++;

    p[toUsed].to = u;
    p[toUsed].nxt = head[v];
    head[v] = toUsed++;
}

void mkTree(int rt,int pre){
    fa[rt][0] = pre;
    dep[rt] = dep[pre] + 1;
    for(int i=1;i<20;++i)
        fa[rt][i] = fa[fa[rt][i-1]][i-1];
    for(int i=head[rt];i!=-1;i=p[i].nxt){
        int sn = p[i].to;
        if(sn==pre) continue;
        mkTree(sn,rt);
    }
}

void dfs(int rt,int pre){
    for(int i=head[rt];i!=-1;i=p[i].nxt){
        int sn = p[i].to;
        if(sn == pre) continue;
        dfs(sn,rt);
        val[rt] += val[sn];
    }
}

void modify(int a,int b){
    val[a]  += 1;
    val[b]  += 1;

    //int lca; val[lca] -=2
    if(dep[a]<dep[b]) swap(a,b);
    /*将a上升到与b同样的高度*/
    int h = dep[a] - dep[b];//高度差

    for(int i=0;(1<<i)<=h;++i)
        if(h&(1<<i)) a = fa[a][i];//前进2^i步
    //cout<<a<<" "<<b<<endl;
    for(int i=20-1;i>=0;--i){
        if(fa[a][i]==fa[b][i]) continue;
        a = fa[a][i];
        b = fa[b][i];
    }
    if(a!=b) a=fa[a][0];
    val[a] -= 2;
}
int main(){
    int n;
    scanf("%d",&n);
    memset(head,-1,sizeof head);
    memset(val,0,sizeof val);
    memset(fa,0,sizeof fa);
    for(int i=2;i<=n;++i){
        int u,v;
        scanf("%d%d%d",&u,&v,&w[i]);
        mkedge(u,v);
    }
    dep[0] = -1;
    mkTree(1,0);
    int q;
    scanf("%d",&q);
    while(q--){
        int a,b;
        scanf("%d%d",&a,&b);
        modify(a,b);
    }

    dfs(1,0);
    sort(val+2,val+n+1);
    sort(w+2,w+n+1);
    llt ans = 0;
    for(int i=n;i>=2;i--)
        ans += 1LL*val[i]*w[n-i+2];
    printf("%lld\n",ans);
}

二、求连续编号节点的LCA

最近的热身赛碰到的一道好题，就是求节点的编号为连续[L,R]的最近公共祖先lca！明显树上倍增求lca！然后RMQ记录已id为区间左端点长度为2次幂的编号连续的节点的lca预处理得出。然后应对询问

lca[l][2k]=LCA(lca[l][2k−1],lca[l+2k−1][2k−1]) l c a [ l ] [ 2 k ] = L C A ( l c a [ l ] [ 2 k − 1 ] , l c a [ l + 2 k − 1 ] [ 2 k − 1 ] )

`ural 2109
题意： 给一棵树，q次询问节点[L,R]的lca。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <math.h>
#include <map>
#include <cstdlib>
#define lson (rt<<1)
#define rson ((rt<<1)+1)
using namespace std;
typedef long long ll;

const int N = 2e5+777;

inline int read() {
    char ch = getchar(); int x = 0, f = 1;
    while(ch < '0' || ch > '9') {
        if(ch == '-') f = -1;
        ch = getchar();
    } while('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    } return x * f;
}
struct edge{
    int to;
    int nxt;
}ed[N*2];

int toUsed ;
int head[N];
void add_edge(int u,int v){
    ed[toUsed].to = v;
    ed[toUsed].nxt = head[u];
    head[u] = toUsed++;

    ed[toUsed].to = u;
    ed[toUsed].nxt = head[v];
    head[v] = toUsed++;
}
int fa[N][22],dep[N];
int lca[N][22];
int n;
void dfs(int rt,int pre){
     //cout<<rt<<" "<<pre<<endl;
     fa[rt][0]=pre;
     dep[rt] = dep[pre]+1;
     for(int i=1;i<=20;++i)
        fa[rt][i] = fa[fa[rt][i-1]][i-1];
     for(int i=head[rt];i!=-1;i=ed[i].nxt){
        int v = ed[i].to;
        if(v==pre) continue;
        dfs(v,rt);
     }
}
inline int find_LCA(int x,int y){

    if(dep[x]<dep[y]) swap(x,y);
    int d = dep[x]-dep[y];
    for(int i=0;(1<<i)<=d;++i)
        if((1<<i)&d) {
           x = fa[x][i];
           d -= (1<<i);
        }
    if(x==y) return x;
    //cout<<x<<" "<<y<<endl;
    for(int i=20;i>=0;--i){
        if(fa[x][i]==fa[y][i]) continue;
        x =fa[x][i];
        y =fa[y][i];
        //cout<<x<<" "<<y<<endl;
    }
    return fa[x][0];
}


int main(){
    while(~scanf("%d",&n)){
        toUsed = 1;
        memset(head,-1,sizeof head);
        memset(fa,0,sizeof fa);
        memset(lca,0,sizeof lca);
        for(int i=1;i<n;++i){
            int u,v;
            //scanf("%d%d",&u,&v);
            u = read(); v = read();

            cout <<u<<" "<<v<<endl;
            cout<<endl;
            add_edge(u,v);
        }
        dep[0]=0;
        dfs(1,0);
        /*cout<<fa[3][0]<<" "<<fa[11][0]<<endl;*/
        for(int i=1;i<=n;++i)  lca[i][0] = i;
        for(int j=1;(1<<j)<=n;++j)
            for(int i=1;i+(1<<j)-1<=n;++i)
               lca[i][j] = find_LCA(lca[i][j-1],lca[i+(1<<(j-1))][j-1]);
        int q;
       // scanf("%d",&q);
        q = read();
        while(q--){
            int l,r;
            //scanf("%d%d",&l,&r);
            l = read(); r = read();

            int d = (int)( log((double)(r-l+1)) / log(2.0) );
            //cout<<d<<endl;
            //cout<<lca[l][d]<<" "<<lca[r-(1<<d)+1][d]<<endl;
            printf("%d\n",find_LCA(lca[l][d],lca[r-(1<<d)+1][d]));
        }
    }
    return 0;
}
/*********

13
1 2
1 10
10 11
2 6
5 6
4 6
3 4
2 12
12 13
2 7
7 8
7 9
10
**************/

三、贪心+树上倍增

树上节点i的权值为2^i, 删去k个节点后仍然为树，问留下的树的节点权值和最大值

CF 980E
贪心做法，显然2^n >其它n-1个节点权值之和，所以建立以节点n为根的树，然后逐一判断n-1、n-2……1,如果它到达已经在确定留在树上的节点的距离大于x(剩下留在树上的节点数），我们必须舍去！否则将其路径上的点全变为确定留在树上！

/*******************************************************************
**   给你一棵树，树上节点的权值为其idx 的2^idx，问删去k个节点，仍为树，
   问留下哪n-k个节点的权值之和最大。
**  明显： 第n节点肯定保留，其余剩下所有节点的和小于其权值；
    建立以节点n为根的树！

    找其它n-k-1个点，就有点难了！ 找此时最大的节点，必须确定它的未确定保留的最远祖先的位置(层数)
如果之间长度为x 远大于现在能保留的个数，我们就必须舍弃此点。
    查找的话如果我们简单查询距离，那么准备超时了！
    倍增查询！


********************************************************************/

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <set>
#include <queue>
#include <map>
#include <vector>
#include <stack>
#define llt long long
#define Ld long double
#define lson (rt<<1)
#define rson ((rt<<1)+1)

using namespace std;
typedef pair<int,int> pii;

const int Size = 1e6+7;
int fa[Size][22],dep[Size],q[Size];//q 记录 被保留
vector <int> V[Size];
vector <int> Ans;
void init(){
    memset(fa,0,sizeof(fa));
    memset(q,0,sizeof(q));
    memset(dep,0,sizeof(dep));
    memset(V,0,sizeof(V));
    Ans.clear();
}

// create tree = dfs
// create redouble relation
void mk_Tree(int rt){
    for(int i=1;i<=20;++i)
        fa[rt][i] = fa[fa[rt][i-1]][i-1];
    int num = V[rt].size();
    for(int i=0;i<num;++i){
        int sn = V[rt][i];
        //cout<<sn<<endl;
        if(fa[rt][0]==sn) continue;
        fa[sn][0] = rt;
        dep[sn] = dep[rt] + 1;
        mk_Tree(sn);
    }
}

int main()
{
    int n,k;
    scanf("%d %d",&n,&k);

    int a,b;
    init();
    for(int i=1;i<n;++i){
        scanf("%d %d",&a,&b);
        V[a].push_back(b);
        V[b].push_back(a);
    }
    fa[n][0] = 0;//can't -1
    q[n] = 1;
    Ans.push_back(n);
    mk_Tree(n);

    int r = n - k - 1;//记录需要保留的点个数
    for(int i=n-1;i>=1&&r;--i){
        if(q[i]) continue;

        // 倍增查找
        int tmp = i;
        for(int j=log2(1.0*n);j>=0;--j){
            if(fa[tmp][j]==0) continue;
            int sn = fa[tmp][j];
            if(q[sn]==0)  tmp = sn;//前进2^j个单位
        }

        if(dep[i]-dep[tmp]+1>r) continue;
        q[i] = 1;
        r-=(dep[i]-dep[tmp]+1);
        int t=i;
        while(t!=tmp){
            t = fa[t][0];
            q[t] = 1;
        }
    }

    for(int i=1;i<=n;++i)
       if(q[i]==0&&k--) printf("%d%c",i,(k==0)?'\n':' ');
    return 0;
}
隆1
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简析树上倍增
u013455437的博客
06-06 269
树上倍增，可在树的某条链上随深度具有某种单调的性质时进行查找，使时间复杂度从暴力查找的O(N)O(N)O(N)变为O(log⁡N)O(\log N)O(logN)。 树上倍增需要构建数组f[N][⌈log⁡N⌉]f[N][\left \lceil \log N \right \rceil ]f[N][⌈logN⌉]，其中f[n][i]f[n][i]f[n][i]代表的是从结点nnn向根节点方向走2i2^i2i步到达的结点。 很显然，f[n][0]f[n][0]f[n][0]即结点nnn的父节点，在建图时即可
树上倍增
Black__wing的博客
01-16 1748
对于在树上查找某点的祖先，如果简单的查找时间复杂度是o(n)，那么，我们可以通过倍增算法优化这个时间复杂度，将每次跳一个点变成，每次跳2的i次方个点，也就是倍增优化这个过程，将时间复杂度变为o(logn)。 如何进行倍增？ 首先我们需要进行一遍dfs初始化，处理出每个点的深度。根据深度，初始化fa[now][i]，fa数组存的是now节点的2得i次方倍祖先。 这样处理完成后，我们来看树上倍增...
树上倍增法求最近公共祖先LCA
FlushHip
02-26 883
LCA，最近公共祖先，这个东西有很多作用，因此，如何高效求出LCA就成了一个热点的讨论话题。下面所有的讨论都以图中这棵树为例子。先来了解下什么是倍增吧，倍增其实就是二分的逆向，二分是逐渐缩小范围，而倍增是成倍扩大。这里的倍增借用二进制来表达更容易理解；
倍增算法应用
qq_42852687的博客
04-06 1282
倍增算法一，概述二，基础应用三，实际例子0，趣味知识1， 倍增+最短路2，倍增优化DP 一，概述 倍增法（英语：binary lifting），顾名思义就是翻倍。它能够使线性的处理转化为对数级的处理，大大地优化时间复杂度。 基于使得所需区间由2的整数幂拼凑而成 二，基础应用 正序预处理+倒叙拼凑型 1，预处理f[i][j]=f[i−1][f[i−1][j]]+...f[i][j]=f[i-1][f[i-1][j]]+...f[i][j]=f[i−1][f[i−1][j]]+...，与一种Dp类似 2，
树上倍增LCA题集
帅比王的博客
10-09 788
树上倍增法可以用于求LCA，当然在其它场合也有应用，在很多时候看似不是树形的问题，我们也可以通过转化成树形结构，然后在树中进行操作，这种操作可以是求二者之间的最近状态，或者是二者之间的距离，如最后一题。 另外关于树的题型，最好还是根据样例画图思考，往往可以比空想获得更多思路。 点的距离 题意简述 给定一棵 n 个点的树，Q 个询问，每次询问点 x 到点 y 两点之间的距离。 解题思路 模板题，用树...
树上倍增_黄哲威.pdf
09-14
在这篇文章中，我们将详细介绍树上倍增算法的原理、实现和应用。 1. 什么是树上倍增算法？ 树上倍增算法是一种用于解决树上最近公共祖先问题的算法。该算法的主要思想是预处理树上每个结点的深度和父亲结点，然后...
LCA-树上差分.pdf
最新发布
05-10
倍增求LCA的核心是利用树上倍增法，构建一个f[][]数组，其中f[x][k]表示节点x向上跳2^k步到达的祖先节点。通过动态规划的方式，先计算f[x][1]，然后递归地计算f[x][i]，直到i等于20，足以覆盖所有可能的深度。在查询...
倍增法介绍以及应用（RMQ、LCA）
02-08
倍增法介绍以及应用（RMQ、LCA） 倍增法是一种常用的算法思想，广泛应用于解决范围查询、最近公共祖先等问题。下面，我们将详细介绍倍增法的定义、应用以及优化方法。 倍增法定义 ---------- 倍增法是指每个数是...
树上算法选讲.pptx
02-12
- 使用倍增法处理动态路径查询，如树上路径边权最大值问题，可以预处理g[u][i]表示u向上跳2^i构成的路径的最大值。 5. **树上动态规划（树DP）**： - **最大子树和**：以i为根的连通块的最大点权和F[i] = F[i] + ...
Pascal LCA 倍增法详解及代码
10-08
最近公共祖先（LCA）问题在计算机科学，特别是在图论和数据结构中具有重要的应用，尤其是在树形数据结构的处理中。LCA指的是在一棵有根树中，给定两个节点u和v，找到离根最远的那个节点r，使得r既是u的祖先也是v的...
倍增思想在算法中的应用
10-08
倍增思想在算法中的应用，感觉这个课件不错 就收藏并分享咯~
树上倍增求LCA
OIER成长之路
07-24 1258
树上倍增求LCA
P1084 [NOIP2012 提高组] 疫情控制
You_are_hanson的博客
07-18 1225
P1084 [NOIP2012 提高组] 疫情控制
倍增的两个简单应用
juruo_c的博客
01-31 134
文章目录LCA（最近公共祖先）静态RMQ（ST表查询） LCA（最近公共祖先） 首先遍历一次预处理 void dfs(int now,int fath){ fa[now][0] = fath;dep[now] = dep[fath] + 1; for(int i = 1;i <= lg[dep[now]];i ++){ fa[now][i] = fa[fa[now][i - 1]][i - 1]; } for(int i = head[now];i;i
图论--LCA--树上倍增法（在线）
日拱一卒,功不唐捐
10-23 2623
/* * LCA在线算法(倍增法) */ const int MAXN = 10010; const int DEG = 20; struct Edge { int to, next; } edge[MAXN * 2]; int head[MAXN], tot; void addedge(int u, int v) { edge[tot].to = v; e...
树上倍增求LCA（最近公共祖先）
weixin_30376163的博客
10-24 125
前几天做faebdc学长出的模拟题，第三题最后要倍增来优化，在学长的讲解下，尝试的学习和编了一下倍增求LCA（我能说我其他方法也大会吗？。。） 倍增求LCA： father【i】【j】表示节点i往上跳2^j次后的节点 可以转移为 father【i】【j】=father【father【i】【j-1】】【j-1】 （此处注意循环时先循环j，再循环i） 然后df...
zoj 3649 树上的倍增法
写东西的地方
05-09 708
Social Net Time Limit: 5 Seconds      Memory Limit: 65536 KB There are n individuals(2 n <= 30000). Everyone has one or more friends. And everyone can contact all people by friend-relation. If
树上倍增LCA
shi_zi_183的博客
08-21 348
树上倍增LCA LCA：最近公共祖先 朴素思想求LCA，有x，y两点，x、y有不同的深度，depth[x]、depth[y]。首先取x，y的深度最大的点一步一步往上追溯直到x与y的深度相同，再x与y共同追溯直到发现到相同的一点，这一点就是最近公共祖先。 但显然这种一步一步非常慢，所以就要用到倍增求LCA 倍增是指每次跳着走，每次跳2的i次方的点。对于跳点的定位需要一个数组f[x][i]x是点的下标，i是x的第2的x次方祖先，i为零时f[x][0]就是x的父亲。用一次dfs就可以求出f数组。 同朴素的步骤一样
[算法]树上倍增求LCA
adx33526的博客
10-18 183
　　LCA指的是最近公共祖先(Least Common Ancestors)，如下图所示: 　　4和5的LCA就是2 　　那怎么求呢？最粗暴的方法就是先dfs一次，处理出每个点的深度 　　然后把深度更深的那一个点（4）一个点地一个点地往上跳，直到到某个点（3）和另外那个点（5）的深度一样 然后两个点一起一个点地一个点地往上跳，直到到某个点（就是最近公共祖先）两个点“变”成...
倍增设计技术：并行计算在链表与树结构中的应用
中科大的讲义深入探讨了并行计算的基础理论和实践应用。课程首先介绍了并行计算机系统及其结构模型，包括SMP（Symmetric Multi-Processing）、MPP（Massively Parallel Processing）和Cluster架构，以及如何评估并行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值