cf588e & bzoj3306 树上倍增

最新推荐文章于 2024-02-19 07:41:06 发布
最新推荐文章于 2024-02-19 07:41:06 发布
阅读量865 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： ACM/ICPC 文章标签： 树上倍增 LCA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u012915516/article/details/49532251
本文介绍了树上倍增技术在解决竞赛编程问题中的应用，包括点上的树上倍增和边上的树上倍增。点上的树上倍增用于处理节点信息，而边上的树上倍增关注路径上的最大和次大边。通过定义特殊的加法操作，可以高效地维护路径上的关键数据，并避免在路径上加入LCA点的信息。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

树上倍增：

fa[i][j]:=结点i的第2^j父亲结点  更新方式为f[i][j]=fa[fa[i][j-1]][j-1]

d[i][j]:=从结点i（包含）到第2^j父亲结点（不包含）路径上面的信息，更新方式为d[i][j]=d[i][j-1]+d[fa[i][j-1]][j-1]

根据实际情况重新定义operator + 运算           一般储存的都是最值信息

重新定义operator + 运算  更加容易理清思路~~~~


cf588E：   点上的树上倍增

题意：给一棵树（n个点），树上结点住着一些人（下标从1--m），输出（u,v）路径上面的所有人根据下标排序后的前a个人的下标（a<=10）

解法：

d[i][j]:=是一个拥有一个大小为10的数组的struct 类型，

d[i][j]=d[i][j-1]+d[fa[i][j-1]][j-1]，直接记录这个路径上下标最小的前10个即可~~重新定义+运算

#include <algorithm>
#include <iostream>
#include<string.h>
#include <fstream>
#include <math.h>
#include <vector>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define exp 1e-8
#define fi first
#define se second
#define ll long long
#define INF 0x3f3f3f3f
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define all(a) a.begin(),a.end()
#define mm(a,b) memset(a,b,sizeof(a));
#define for0(a,b) for(int a=0;a<=b;a++)//0---(b-1)
#define for1(a,b) for(int a=1;a<=b;a++)//1---(b)
#define rep(a,b,c) for(int a=b;a<=c;a++)//b---c
#define repp(a,b,c)for(int a=b;a>=c;a--)///
#define cnt_one(i) __builtin_popcount(i)
#define stl(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
using namespace std;
void bug(string m="here"){cout<<m<<endl;}
template<typename __ll> inline void READ(__ll &m){__ll x=0,f=1;char ch=getchar();while(!(ch>='0'&&ch<='9')){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}m=x*f;}
template<typename __ll>inline void read(__ll &m){READ(m);}
template<typename __ll>inline void read(__ll &m,__ll &a){READ(m);READ(a);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b){READ(m);READ(a);READ(b);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c){READ(m);READ(a);READ(b);READ(c);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c,__ll &d){READ(m);READ(a);READ(b);READ(c);read(d);}
template < class T > inline  void out(T a){if(a<0){putchar('-');a=-a;}if(a>9)out(a/10);putchar(a%10+'0');}
template < class T > inline  void outln(T a){out(a);puts("");}
template < class T > inline  void out(T a,T b){out(a);putchar(' ');out(b);}
template < class T > inline  void outln(T a,T b){out(a);putchar(' ');outln(b);}
template < class T > inline  void out(T a,T b,T c){out(a);putchar(' ');out(b);putchar(' ');out(c);}
template < class T > inline  void outln(T a,T b,T c){out(a);putchar(' ');outln(b);putchar(' ');outln(b);}
template < class T > T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template < class T > T lcm(T a, T b) { return a / gcd(a, b) * b; }
template < class T > inline void rmin(T &a, const T &b) { if(a > b) a = b; }
template < class T > inline void rmax(T &a, const T &b) { if(a < b) a = b; }
template < class T > T pow(T a, T b) { T r = 1; while(b > 0) { if(b & 1) r = r * a; a = a * a; b /= 2; } return r; }
template < class T > T pow(T a, T b, T mod) { T r = 1; while(b > 0) { if(b & 1) r = r * a % mod; a = a * a % mod; b /= 2; } return r; }

const int cnt_edge=200010;  //Ð޸İ¡
const int cnt_v=100010;
int head[cnt_v],cnt_e;
struct EDGE{int v,next,cost;}edge[cnt_edge];
void addedge(int u,int v,int cost=0)
{edge[cnt_e].v=v;edge[cnt_e].cost=cost;edge[cnt_e].next=head[u];head[u]=cnt_e++;}
void init(){cnt_e=0;memset(head,-1,sizeof(head));}
struct data
{
    int n;
    int p[15];
    data(){n=0;}
    void add(int num)
    {
        int pos=lower_bound(p,p+n,num)-p;
        for(int i=n;i>pos;i--)p[i]=p[i-1];
        p[pos]=num;
        n=min(n+1,10);
    }
    void print()
    {
        if(n!=0)
            out(n),putchar(' ');
        else outln(n);
        for(int i=0;i<n;i++)
        {
            if(i==n-1)outln(p[i]);
            else out(p[i]),putchar(' ');
        }
    }
}d[100010][25];
data operator +(const data &a,const data &b){///重新定义
    data c;
    int i=0,j=0;
    while(i<a.n&&j<b.n&&c.n<10)
    {
        if(a.p[i]<b.p[j])c.p[c.n++]=a.p[i++];
        else c.p[c.n++]=b.p[j++];
    }
    while(i<a.n&&c.n<10)
    c.p[c.n++]=a.p[i++];
    while(j<b.n&&c.n<10)
    c.p[c.n++]=b.p[j++];
    return c;
}
int deep[100010];
int fa[100010][25];
int n,m,q;
void dfs(int u,int f,int dee)
{
    fa[u][0]=f;
    deep[u]=dee;
    for(int i=1;i<=20;i++)
    {
        if(deep[u]<(1<<i))break;
        fa[u][i]=fa[fa[u][i-1]][i-1];
        d[u][i]=d[u][i-1]+d[fa[u][i-1]][i-1];
    }
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==f)continue;
            dfs(v,u,dee+1);
    }
}
void lca(int x,int y,int k)
{
    data ans;
    if(deep[x]<deep[y])swap(x,y);
    int t=deep[x]-deep[y];
    for(int i=0;i<=20;i++)
        if(t&(1<<i))
        {
            ans=ans+d[x][i];
            x=fa[x][i];
        }
    if(x==y)
    {
        ans=ans+d[x][0];
        ans.n=min(ans.n,k);
        ans.print();
        return;
    }
    for(int i=20;i>=0;i--)
        if(fa[x][i]!=fa[y][i])
        {
            ans=ans+d[x][i]+d[y][i];
            x=fa[x][i];
            y=fa[y][i];
        }
    ans=ans+d[x][0]+d[y][0];
    x=fa[x][0];
    ans=ans+d[x][0];
    ans.n=min(ans.n,k);
    ans.print();
}
int main()
{
    init();
    read(n,m,q);
    for1(i,n-1)
    {
        int a,b;read(a,b);
        addedge(a,b);
        addedge(b,a);
    }
    for1(i,m)
    {
        int idx;read(idx);
        d[idx][0].add(i);
    }
    dfs(1,0,0);
    while(q--)
    {
        int a,b,c;
        read(a,b,c);
        lca(a,b,c);
    }
}


BZOJ1977：边上的树上倍增

题意：求次小生成树，要求严格最小，即最小生成树权值为EM,要求生成的次小生成树ES>EM

解法：先求出最小生成树。然后每次加一条未用过的边<u,n>，求出树<u,v>路径上最大的边和第二大的边，要么删除最大的边或者删除第二大的边然后加入当前未用过的边生成次小生成树

d[i][j]:=是一个拥有first、second的struct类型

d[i][j]=d[i][j-1]+d[fa[i][j-1]][j-1]，直接记录这个路径上最大和次大~~重新定义+运算


边上的树上倍增把边的信息放到深度比较大的点进行保存，然后转成点上的树上倍增。

只是最后不能加上LCA这个点的信息~~


#include <algorithm>
#include <iostream>
#include<string.h>
#include <fstream>
#include <math.h>
#include <vector>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define exp 1e-8
#define fi first
#define se second
#define ll long long
#define INF 0x3f3f3f3f
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define all(a) a.begin(),a.end()
#define mm(a,b) memset(a,b,sizeof(a));
#define for0(a,b) for(int a=0;a<=b;a++)//0---(b-1)
#define for1(a,b) for(int a=1;a<=b;a++)//1---(b)
#define rep(a,b,c) for(int a=b;a<=c;a++)//b---c
#define repp(a,b,c)for(int a=b;a>=c;a--)///
#define cnt_one(i) __builtin_popcount(i)
#define stl(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
using namespace std;
void bug(string m="here"){cout<<m<<endl;}
template<typename __ll> inline void READ(__ll &m){__ll x=0,f=1;char ch=getchar();while(!(ch>='0'&&ch<='9')){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}m=x*f;}
template<typename __ll>inline void read(__ll &m){READ(m);}
template<typename __ll>inline void read(__ll &m,__ll &a){READ(m);READ(a);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b){READ(m);READ(a);READ(b);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c){READ(m);READ(a);READ(b);READ(c);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c,__ll &d){READ(m);READ(a);READ(b);READ(c);read(d);}
template < class T > inline  void out(T a){if(a<0){putchar('-');a=-a;}if(a>9)out(a/10);putchar(a%10+'0');}
template < class T > inline  void outln(T a){out(a);puts("");}
template < class T > inline  void out(T a,T b){out(a);putchar(' ');out(b);}
template < class T > inline  void outln(T a,T b){out(a);putchar(' ');outln(b);}
template < class T > inline  void out(T a,T b,T c){out(a);putchar(' ');out(b);putchar(' ');out(c);}
template < class T > inline  void outln(T a,T b,T c){out(a);putchar(' ');outln(b);putchar(' ');outln(b);}
template < class T > T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template < class T > T lcm(T a, T b) { return a / gcd(a, b) * b; }
template < class T > inline void rmin(T &a, const T &b) { if(a > b) a = b; }
template < class T > inline void rmax(T &a, const T &b) { if(a < b) a = b; }
template < class T > T pow(T a, T b) { T r = 1; while(b > 0) { if(b & 1) r = r * a; a = a * a; b /= 2; } return r; }
template < class T > T pow(T a, T b, T mod) { T r = 1; while(b > 0) { if(b & 1) r = r * a % mod; a = a * a % mod; b /= 2; } return r; }

const int cnt_edge=200010;  //Ð޸İ¡
const int cnt_v=100010;
int head[cnt_v],cnt_e;
struct EDGE{int v,next,cost;}edge[cnt_edge];
void addedge(int u,int v,int cost=0)
{edge[cnt_e].v=v;edge[cnt_e].cost=cost;edge[cnt_e].next=head[u];head[u]=cnt_e++;}
void init(){cnt_e=0;memset(head,-1,sizeof(head));}
struct data
{
    int n;
    int p[15];
    data(){n=0;}
    void add(int num)
    {
        int pos=lower_bound(p,p+n,num)-p;
        for(int i=n;i>pos;i--)p[i]=p[i-1];
        p[pos]=num;
        n=min(n+1,10);
    }
    void print()
    {
        if(n!=0)
            out(n),putchar(' ');
        else outln(n);
        for(int i=0;i<n;i++)
        {
            if(i==n-1)outln(p[i]);
            else out(p[i]),putchar(' ');
        }
    }
}d[100010][25];
data operator +(const data &a,const data &b){///重新定义
    data c;
    int i=0,j=0;
    while(i<a.n&&j<b.n&&c.n<10)
    {
        if(a.p[i]<b.p[j])c.p[c.n++]=a.p[i++];
        else c.p[c.n++]=b.p[j++];
    }
    while(i<a.n&&c.n<10)
    c.p[c.n++]=a.p[i++];
    while(j<b.n&&c.n<10)
    c.p[c.n++]=b.p[j++];
    return c;
}
int deep[100010];
int fa[100010][25];
int n,m,q;
void dfs(int u,int f,int dee)
{
    fa[u][0]=f;
    deep[u]=dee;
    for(int i=1;i<=20;i++)
    {
        if(deep[u]<(1<<i))break;
        fa[u][i]=fa[fa[u][i-1]][i-1];
        d[u][i]=d[u][i-1]+d[fa[u][i-1]][i-1];
    }
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==f)continue;
            dfs(v,u,dee+1);
    }
}
void lca(int x,int y,int k)
{
    data ans;
    if(deep[x]<deep[y])swap(x,y);
    int t=deep[x]-deep[y];
    for(int i=0;i<=20;i++)
        if(t&(1<<i))
        {
            ans=ans+d[x][i];
            x=fa[x][i];
        }
    if(x==y)
    {
        ans=ans+d[x][0];
        ans.n=min(ans.n,k);
        ans.print();
        return;
    }
    for(int i=20;i>=0;i--)
        if(fa[x][i]!=fa[y][i])
        {
            ans=ans+d[x][i]+d[y][i];
            x=fa[x][i];
            y=fa[y][i];
        }
    ans=ans+d[x][0]+d[y][0];
    x=fa[x][0];
    ans=ans+d[x][0];
    ans.n=min(ans.n,k);
    ans.print();
}
int main()
{
    init();
    read(n,m,q);
    for1(i,n-1)
    {
        int a,b;read(a,b);
        addedge(a,b);
        addedge(b,a);
    }
    for1(i,m)
    {
        int idx;read(idx);
        d[idx][0].add(i);
    }
    dfs(1,0,0);
    while(q--)
    {
        int a,b,c;
        read(a,b,c);
        lca(a,b,c);
    }
}




树上倍增
Black__wing的博客
01-16 1899
对于在树上查找某点的祖先，如果简单的查找时间复杂度是o(n)，那么，我们可以通过倍增算法优化这个时间复杂度，将每次跳一个点变成，每次跳2的i次方个点，也就是倍增优化这个过程，将时间复杂度变为o(logn)。 如何进行倍增？ 首先我们需要进行一遍dfs初始化，处理出每个点的深度。根据深度，初始化fa[now][i]，fa数组存的是now节点的2得i次方倍祖先。 这样处理完成后，我们来看树上倍增...
BZOJ 4082 Wf2014 Surveillance 树上倍增
世界
05-22 2341
题目大意：给定一个nn个点的环，有kk个区间，要求选择最少的区间覆盖所有点首先我们考虑链上版本，显然我们有一个贪心的做法： 从1号节点开始，每次选择能向后走的最远的区间，直到走完所有节点为止 正确性显然 但是到了环上版本我们却不能直接套用这个算法，因为环上不存在所谓的“1号节点” 因此我们这样做： 拆环后将序列倍增，把所有区间按照右端点从小到大排序 每个区间向这个区间右端点向后能走的最远
B20J ：5165: 树上倍增
dianjia2824的博客
06-30 219
5165: 树上倍增 Description 现有一棵树。您需要写一个树上倍增算法，以实现如下操作： A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。 Q k p1 p2 p3.... 查询p1,p2,p3...这些节点的LCA。其中k表示查询节点的个数。 最初树上只有一个节点，编号为1。 多个节点的LCA定义为：这些节点的公共祖先中深度最大...
CF 609E 树上的倍增
aiyi9685的博客
08-16 214
1 /* 2 Source :CF 609E 3 Problem :给定n个顶点，m条边的图，对于一条边，求包含这条边的最小生成树 4 Solution :先求出MST,然后对于一条给定的边，对应的最小生成树为MST中去掉u,v路径上的最大的边，然后加上当前的边 5 对于后面的问题，求解u，v路径上的最大边，可用树...
树上倍增（模板）
百般回首曾经的相遇，留下的只是一缕残忆
12-07 385
#include&lt;cstdio&gt; #include&lt;string&gt; #include&lt;vector&gt; #include&lt;algorithm&gt; #define N 100009 using namespace std; vector&lt;int&gt; tree[N]; int father[N][21], h[N], w[N]; void df...
【总结】带权二分/斜率凸优化/WQS二分-bzoj2654tree&bzoj4609Branch Assignment&bzoj5252林克卡特树
远行客
02-28 846
带权二分/斜率凸优化/WQS二分
【数据结构题目讲解】BZOJ 3306 - 树 利用DFS序求解
最新发布
Edward Shi的博客
02-19 975
BZOJ 3306 - 树： 利用DFS序求解该题的思路
wangjunrui666#bzoj-problem##5165. 树上倍增1
07-25
您需要写一个树上倍增算法，以实现如下操作：A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。保证询问不超过1000次输出格式对于每一个Q操作，
分治技巧在高级数据结构中的应用——线段树分治（二）&&bzoj4137火星商店问题详解
maxtir的博客
12-01 2823
分治技巧在高级数据结构中的应用——线段树分治（二） 从一道神题说起 4137: [FJOI2015]火星商店问题 Time Limit: 20 Sec  Memory Limit: 256 MB Submit: 210  Solved: 98 [Submit][Status][Discuss] Description 火星上的一条商业街里按照商店的编号1，2 ，…，n ，
[bzoj5165][树上倍增]树上倍增
Rose_max的博客
04-09 678
Description 现有一棵树。您需要写一个树上倍增算法，以实现如下操作： A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。 Q k p1 p2 p3…. 查询p1,p2,p3…这些节点的LCA。其中k表示查询节点的个数。 最初树上只有一个节点，编号为1。 多个节点的LCA定义为：这些节点的公共祖先中深度最大的。 Input 第一行，一个正...
树上倍增法
实践求真知
09-05 1207
最近公共祖先
CodeForces-932D Tree（树上倍增）
Paulliant的博客
08-05 435
题意 给定一个编号为 111 ，权重为 000 的点。在线完成下面两种操作（QQQ 个操作）： 1.1.1. 将一个权重为 WWW 的点加入到编号为 RRR 的节点之下。 2.2.2. 询问从 RRR 开始，权重和不超过 XXX 的最长合法序列的长度。 其中一个合法的序列满足从 RRR 开始向祖先走，每当遇到一个权值大于等于目前序列最后一个点的权值时，都将它加入序列末端（构建序列的决策是单...
【Codeforces 932D】 Tree | 树上倍增
一只酷酷光儿的博客
12-02 379
题目链接：https://codeforces.com/contest/932/problem/D 题目大意： 起初是一个点，对于这个点要进行q次操作 1操作：1 x y 新增一个节点，它的父节点x，它的权值是num[y] 2操作：2 x y 询问以x开头的，满足所有点在x到根节点的路径上，并且权值单调不减，并且总权值小于等于x的最长路径长度 题目思路： 这个题类似：原题 首先可以确定是一个树，因为每个节点只有一个父亲节点 所以可以在树上进行倍增维护这个信息 f[i][j] 代表 i 到
【BZOJ 5165】 树上倍增
even_bao的博客
06-05 431
【题目链接】           点击打开链接【算法】           树上倍增，时间复杂度 ： O(qklog(n))【代码】         #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; #define MAXN 3000010 #define MAXLOG 18 const int INF = 1e8; int T,tot = 1...
codeforces 932D. Tree(树上倍增)
the best 的博客
07-28 206
题意： 给出一个初始点只有1的树，权值为0，有两种操作： 1.1.1. 往树中加入一个节点 2.查询从某个节点起，往祖先方向能找到的最长非降子序列。要求：权值和不能超过xxx ,并且后一个点是前一个点的祖先，且必须是最近的，权值≥\geq≥ 前一个点的祖先。 操作强制在线。 题解： 像这种往祖先方向查询的操作，可以考虑倍增法。 设dp[i][j]dp[i][j]dp[i][j]​ 表示节点iii 向上找长度为2j2^j2j 的非降子序列后所处的位置 设sum[i][j]sum[i][j]sum[i][j]
HDU4822 Tri-war 树上倍增
chy2003的博客
08-05 470
题目传送门 ： http://acm.hdu.edu.cn/showproblem.php?pid=4822 题目大意 给定一棵树，和树上节点AAA、BBB、CCC，若节点XXX到节点AAA的距离严格小于到BBB、CCC的距离，那么称XXX被AAA占有。有若干询问，每次给定一组AAA、BBB、CCC，问各占领的节点数。 问题分析 若此题三个点减为两个点AAA、BBB，那么题目应该不...
浅谈树上倍增
cdy1206473601的博客
08-15 784
Tarjan LCA http://blog.youkuaiyun.com/cdy1206473601/article/details/77104910 讲解 上次写了Tarjan LCA，但是当这棵树是一条链的话，时间复杂度就很高啦！所以，我们可以用倍增来解决。但是，在随机数据下，Tarjan是快于倍增的! 好吧，倍增思想就是设一个fa[i][j]表示i结点的第2j2j2^j级祖先。然后就可以通...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值