链表/树 - 线段树，树状数组

最新推荐文章于 2022-04-20 21:24:13 发布

高达一号

最新推荐文章于 2022-04-20 21:24:13 发布

阅读量869

点赞数

分类专栏：数组，链表树文章标签： acm 线段树

树同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

数组，链表

5 篇文章 0 订阅

订阅专栏

线段树

博客分类：
算法

线段树的构造思想
线段树是一棵二叉树，树中的每一个结点表示了一个区间[a,b]。每一个叶子节点表示了一个单位区间。对于每一个非叶结点所表示的结点[a,b]，其左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2,b]。
例如:

线段树的运用
线段树的每个节点上往往都增加了一些其他的域。在这些域中保存了某种动态维护的信息，视不同情况而定。这些域使得线段树具有极大的灵活性，可以适应不同的需求。

例1:求覆盖线段的总长度
      [10000,22000]   [30300,55000]   [44000,60000]   [55000,60000]
排序得10000，22000，30300，44000，55000，60000
对应得     1，   2，    3，    4，    5，    6
        [1,2]            [3,5]           [4,6]          [5,6]

线段树做法:

例2:http://acm.pku.edu.cn/JudgeOnline/problem?id=2528
题意:贴海报,输出可以看到的个数.

Java代码

//贴海报,输出没有被覆盖的个数
//可以改成cpp试试
#include<stdio.h>
struct node
{
int l,r; //左右孩子的编号
int st,mi,en;
int id;
}; // 线段树简单一维
const int maxN = 50000002; //线段树的节点个数
const int maxL = 10000020; //台阶的宽度上限
node segment_tree[maxN]; //保存着线段树的所有节点
#define tree segment_tree
int root, ptr;
void insert(int cr, int start, int end, int color) //插入到指定区域,同时初始化沿途的所有节点
{
if(start >= end) //不符合输入要求
return;
if(tree[cr].st == start && tree[cr].en == end) //输入区间正好等于节点的表示区间
{
tree[cr].id = color; //这个区间属于该海报
return;
}
int mid = (tree[cr].st + tree[cr].en) / 2;
if(tree[cr].l == 0) //意味着还没有初始化孩子结点
{
//ptr代表节点的编号
tree[cr].l = ptr++;
tree[tree[cr].l].l = tree[tree[cr].l].r = 0;
tree[tree[cr].l].id = -1;
tree[tree[cr].l].st = tree[cr].st, //这里对左右孩子的范围进行初始化
tree[tree[cr].l].en = mid;
}
if(tree[cr].r == 0)
{
tree[cr].r = ptr++;
tree[tree[cr].r].l = tree[tree[cr].r].r = 0;
tree[tree[cr].r].id = -1;
tree[tree[cr].r].st = mid,
tree[tree[cr].r].en = tree[cr].en;
}
if(tree[cr].id != 0) //之后的子区间肯定都属于该海报
{
tree[tree[cr].l].id = tree[tree[cr].r].id = tree[cr].id;
tree[cr].id = 0;
}
if(start >= mid){
insert(tree[cr].r, start, end, color);
return;
}
if(end <= mid){
insert(tree[cr].l, start, end, color);
return;
}
insert(tree[cr].l, start, mid, color);
insert(tree[cr].r, mid, end, color);
}
char exist[10001];
void trail(int cr) //统计可以看见的节点编号
{
if(cr == 0 || tree[cr].id == -1)
return;
exist[tree[cr].id] = 1; //id不为0,意味着只有它可见,但之后的节点都看不见了.
if(tree[cr].id != 0) //不为0意味着后面的区域都要被覆盖.
return;
trail(tree[cr].l);
trail(tree[cr].r);
}
//初始化跟节点
void init()
{
root = 1;
tree[root].l = tree[root].r = tree[root].id = 0;
tree[root].st = 1, tree[root].en = maxL, tree[root].mi = (1 + maxL)/2;
ptr = 2;
}
int main()
{
int test,n,i,l,r;
scanf("%d", &test);
while(test--)
{
init();
scanf("%d",&n);
for(i = 1; i <= n; i++)
{
scanf("%d%d",&l,&r);
insert(1, l, r+1, i); //从根节点开始插入
}
for(i = 1; i <= n; i++)
exist[i] = 0;
trail(1);
int ans = 0;
for(i = 1; i <= n; i++)
if(exist[i])
ans++;
printf("%d\n",ans);
}
return 0;
}

RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中下标在[i,j]里的最小(大）值，也就是说，RMQ问题是指求区间最值的问题

主要方法及复杂度(处理复杂度和查询复杂度)如下:
1.朴素（即搜索） O(n)-O(n)
2.线段树(segment tree) O(n)-O(qlogn)
3.ST（实质是动态规划） O(nlogn)-O(1)

线段树方法:
线段树能在对数时间内在数组区间上进行更新与查询。
定义线段树在区间[i, j] 上如下：
第一个节点维护着区间 [i, j] 的信息。
if i<j , 那么左孩子维护着区间[i, (i+j)/2] 的信息，右孩子维护着区间[(i+j)/2+1, j] 的信息。
可知 N 个元素的线段树的高度为 [logN] + 1(只有根节点的树高度为0) .
下面是区间 [0, 9] 的一个线段树:

线段树和堆有一样的结构, 因此如果一个节点编号为 x ，那么左孩子编号为2*x 右孩子编号为2*x+1.

使用线段树解决RMQ问题，关键维护一个数组M[num]，num=2^(线段树高度+1).
M[i]:维护着被分配给该节点(编号:i 线段树根节点编号:1)的区间的最小值元素的下标。该数组初始状态为-1.

Cpp代码

#include<iostream>
using namespace std;
#define MAXN 100
#define MAXIND 256 //线段树节点个数
//构建线段树,目的:得到M数组.
void initialize(int node, int b, int e, int M[], int A[])
{
if (b == e)
M[node] = b; //只有一个元素,只有一个下标
else
{
//递归实现左孩子和右孩子
initialize(2 * node, b, (b + e) / 2, M, A);
initialize(2 * node + 1, (b + e) / 2 + 1, e, M, A);
//search for the minimum value in the first and
//second half of the interval
if (A[M[2 * node]] <= A[M[2 * node + 1]])
M[node] = M[2 * node];
else
M[node] = M[2 * node + 1];
}
}
//找出区间 [i, j] 上的最小值的索引
int query(int node, int b, int e, int M[], int A[], int i, int j)
{
int p1, p2;
//查询区间和要求的区间没有交集
if (i > e || j < b)
return -1;
//if the current interval is included in
//the query interval return M[node]
if (b >= i && e <= j)
return M[node];
//compute the minimum position in the
//left and right part of the interval
p1 = query(2 * node, b, (b + e) / 2, M, A, i, j);
p2 = query(2 * node + 1, (b + e) / 2 + 1, e, M, A, i, j);
//return the position where the overall
//minimum is
if (p1 == -1)
return M[node] = p2;
if (p2 == -1)
return M[node] = p1;
if (A[p1] <= A[p2])
return M[node] = p1;
return M[node] = p2;
}
int main()
{
int M[MAXIND]; //下标1起才有意义,保存下标编号节点对应区间最小值的下标.
memset(M,-1,sizeof(M));
int a[]={3,1,5,7,2,9,0,3,4,5};
initialize(1, 0, sizeof(a)/sizeof(a[0])-1, M, a);
cout<<query(1, 0, sizeof(a)/sizeof(a[0])-1, M, a, 0, 5)<<endl;
return 0;
}

ST算法（Sparse Table）:它是一种动态规划的方法。
以最小值为例。a为所寻找的数组.
用一个二维数组f(i,j)记录区间[i,i+2^j-1](持续2^j个)区间中的最小值。其中f[i,0] = a[i];
所以，对于任意的一组(i,j)，f(i,j) = min{f(i,j-1),f(i+2^(j-1),j-1)}来使用动态规划计算出来。
这个算法的高明之处不是在于这个动态规划的建立，而是它的查询：它的查询效率是O(1).
假设我们要求区间[m,n]中a的最小值，找到一个数k使得2^k<n-m+1.
这样，可以把这个区间分成两个部分：[m,m+2^k-1]和[n-2^k+1,n].我们发现，这两个区间是已经初始化好的.
前面的区间是f(m,k)，后面的区间是f(n-2^k+1,k).
这样，只要看这两个区间的最小值，就可以知道整个区间的最小值！

Cpp代码

#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
#define M 100010
#define MAXN 500
#define MAXM 500
int dp[M][18];
/*
*一维RMQ ST算法
*构造RMQ数组 makermq(int n,int b[]) O(nlog(n))的算法复杂度
*dp[i][j] 表示从i到i+2^j -1中最小的一个值(从i开始持续2^j个数)
*dp[i][j]=min{dp[i][j-1],dp[i+2^(j-1)][j-1]}
*查询RMQ rmq(int s,int v)
*将s-v 分成两个2^k的区间
*即 k=(int)log2(s-v+1)
*查询结果应该为 min(dp[s][k],dp[v-2^k+1][k])
*/
void makermq(int n,int b[])
{
int i,j;
for(i=0;i<n;i++)
dp[i][0]=b[i];
for(j=1;(1<<j)<=n;j++)
for(i=0;i+(1<<j)-1<n;i++)
dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
}
int rmq(int s,int v)
{
int k=(int)(log((v-s+1)*1.0)/log(2.0));
return min(dp[s][k],dp[v-(1<<k)+1][k]);
}
void makeRmqIndex(int n,int b[]) //返回最小值对应的下标
{
int i,j;
for(i=0;i<n;i++)
dp[i][0]=i;
for(j=1;(1<<j)<=n;j++)
for(i=0;i+(1<<j)-1<n;i++)
dp[i][j]=b[dp[i][j-1]] < b[dp[i+(1<<(j-1))][j-1]]? dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
}
int rmqIndex(int s,int v,int b[])
{
int k=(int)(log((v-s+1)*1.0)/log(2.0));
return b[dp[s][k]]<b[dp[v-(1<<k)+1][k]]? dp[s][k]:dp[v-(1<<k)+1][k];
}
int main()
{
int a[]={3,4,5,7,8,9,0,3,4,5};
//返回下标
makeRmqIndex(sizeof(a)/sizeof(a[0]),a);
cout<<rmqIndex(0,9,a)<<endl;
cout<<rmqIndex(4,9,a)<<endl;
//返回最小值
makermq(sizeof(a)/sizeof(a[0]),a);
cout<<rmq(0,9)<<endl;
cout<<rmq(4,9)<<endl;
return 0;
}

应用:http://acm.pku.edu.cn/JudgeOnline/problem?id=3264

Cpp代码

#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;
#define maxn 50001
int a[maxn];
int dpmax[maxn][40];
int dpmin[maxn][40];
int getmin(int a,int b)
{
if(a<b) return a;
else return b;
}
int getmax(int a,int b)
{
if(a>b) return a;
else return b;
}
void Make_Big_RMQ(int n)
{
int i,j;
for(i=1;i<=n;i++) dpmax[i][0]=a[i];
for(j=1;j<=log((double)n)/log(2.0);j++)
for(i=1;i+(1<<j)-1<=n;i++)
{
dpmax[i][j]=getmax(dpmax[i][j-1],dpmax[i+(1<<(j-1))][j-1]);
}
}
void Make_Min_RMQ(int n)
{
int i,j;
for(i=1;i<=n;i++) dpmin[i][0]=a[i];
for(j=1;j<=log((double)n)/log(2.0);j++)
for(i=1;i+(1<<j)-1<=n;i++)
{
dpmin[i][j]=getmin(dpmin[i][j-1],dpmin[i+(1<<(j-1))][j-1]);
}
}
int get_big_rmq(int a,int b)
{
int k=(int)(log((double)(b-a+1))/log(2.0));
return getmax(dpmax[a][k],dpmax[b-(1<<k)+1][k]);
}
int get_min_rmq(int a,int b)
{
int k=(int)(log((double)(b-a+1))/log(2.0));
return getmin(dpmin[a][k],dpmin[b-(1<<k)+1][k]);
}
int main()
{
int n,i,q,x,y;
while(scanf("%d %d",&n,&q)!=EOF)
{
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
Make_Big_RMQ(n);
Make_Min_RMQ(n);
for(i=1;i<=q;i++)
{
scanf("%d%d",&x,&y);
printf("%d\n",get_big_rmq(x,y)-get_min_rmq(x,y));
}
}
return 0;
}

树状数组

博客分类：
算法

C C++C#编程数据结构

1,用途
树状数组是一种非常优雅的数据结构.当要频繁的对数组元素进行修改,同时又要频繁的查询数组内任一区间元素之和的时候,可以考虑使用树状数组.
换句话说,树状数组最基本的应用:
对于一个数组，如果有多次操作，每次的操作有两种：1、修改数组中某一元素的值，2、求和，求数组元素a[1]+a[2]+…a[num]的和。
2,复杂度
最直接的算法可以在O(1)时间内完成一次修改,但是需要O(n)时间来进行一次查询.而树状数组的修改和查询均可在O(log(n))的时间内完成.
3,生成
设a[1...N]为原数组,定义c[1...N]为对应的树状数组:
c[i] = a[i - 2^k + 1] + a[i - 2^k + 2] + ... + a[i]
其中k为i的二进制表示末尾0的个数,所以2^k即为i的二进制表示的最后一个1的权值.
所以2^k可以表示为n&(n^(n-1))或更简单的n&(-n).

Cpp代码

int lowbit(int n)
{
return n& (-n);
//or return n&(n^(n-1));
}

也就是说，把k表示成二进制1***10000，那么c[k]就是1***00001 + 1***00010 + ... + 1***10000这一段数的和。
举例:

可以看出:设节点编号为x，那么这个节点管辖的区间为2^k个元素。（其中k为x二进制末尾0的个数）
C1 = A1
C2 = A1 + A2
C3 = A3
C4 = A1 + A2 + A3 + A4
C5 = A5
C6 = A5 + A6
C7 = A7
C8 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8
...
C16 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8 + A9 + A10 + A11 + A12 + A13 + A14 + A15 + A16
4,修改
修改一个节点，必须修改其所有祖先，最坏情况下为修改第一个元素，最多有log(n)的祖先。
对a[n]进行修改后,需要相应的修改c数组中的p1, p2, p3...等一系列元素
其中p1 = n, pi+1 = pi + lowbit(pi)
所以修改原数组中的第n个元素可以实现为:

Cpp代码

void Modify(int n, int delta)
{
while(n <= N)
{
c[n] += delta;
n += lowbit(n);
}
}

5,求和
当要查询a[1],a[2]...a[n]的元素之和时,需要累加c数组中的q1, q2, q3...等一系列元素
其中q1 = n,qi+1 = qi - lowbit(qi)
所以计算a[1] + a[2] + .. a[n]可以实现为:

Cpp代码

int Sum(int n)
{
int result = 0;
while(n != 0)
{
result += c[n];
n -= lowbit(n);
}
return result;
}

为什么是效率是log(n)的呢？以下给出证明：
n = n – lowbit(n)这一步实际上等价于将n的二进制的最后一个1减去。而n的二进制里最多有log(n)个1，所以查询效率是log(n)的。

换句话说:
若需改变a[i]，则c[i]、c[i+lowbit(i)]、c[i+lowbit(i)+lowbit(i+lowbit(i)]……就是需要改变的 c数组中的元素。
若需查询s[i]，则c[i]、c[i-lowbit(i)]、c[i-lowbit(i)-lowbit(i- lowbit(i))]……就是需要累加的c数组中的元素。

6,与线段树的比较
树状数组是一个可以很高效的进行区间统计的数据结构。在思想上类似于线段树，比线段树节省空间，编程复杂度比线段树低，但适用范围比线段树小。

7,应用
(1)http://acm.pku.edu.cn/JudgeOnline/problem?id=2155
首先对于每个数A
定义集合up(A)表示{A, A+lowestbit(A), A+lowestbit(A)+lowestbit(A+lowestbit(A))...}
定义集合down(A)表示{A, A-lowestbit(A), A-lowestbit(A)-lowestbit(A-lowestbit(A)) ... , 0}。
可以发现对于任何A<B，up(A)和down(B)的交集有且仅有一个数。
于是对于这道题目来说，翻转一个区间[A,B]（为了便于讨论先把原问题降为一维的情况），我们可以把down(B)的所有元素的翻转次数+1，再把down(A-1)的所有元素的翻转次数-1。而每次查询一个元素C时，只需要统计up(C)的所有元素的翻转次数之和，即为C实际被翻转的次数。
(2)http://acm.pku.edu.cn/JudgeOnline/problem?id=3321
一棵树上长了苹果，每一个树枝节点上有长苹果和不长苹果两种状态，两种操作，一种操作能够改变树枝上苹果的状态，另一种操作询问某一树枝节点一下的所有的苹果有多少。具体做法是做一次dfs，记下每个节点的开始时间low[i]和结束时间high[i]，那么对于i节点的所有子孙的开始时间和结束时间都应位于low[i]和high[i]之间，另外用一个数组c[i]记录附加在节点i上的苹果的个数，然后用树状数组统计low[i]到high[i]之间的附加苹果总数。这里用树状数组统计区间可以用Sum(high[i])-Sum(low[i]-1)来计算。

Cpp代码

#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
//vector<int> g[100005];
struct Node
{
int v;
struct Node *next;
}g[100005];
int n,m,cnt,low[100005],high[100005],c[100005],flag[100005];
bool mark[100005];
void dfs(int v)
{
struct Node *p=g[v].next;
mark[v]=true;
cnt++;
low[v]=cnt;
while(p)
{
if(!mark[p->v])
dfs(p->v);
p=p->next;
}
high[v]=cnt;
}
int lowbit(int k)
{
return k&(-k);
}
void Modify(int num, int v)
{
while(num <= n)
{
c[num]+=v;
num+=lowbit(num);
}
}
int Sum(int num)
{
int ans=0;
while(num > 0)
{
ans+=c[num];
num-=lowbit(num);
}
return ans;
}
int main()
{
int i,a,b,ans;
char temp[10];
struct Node *p;
//freopen("in.txt","r",stdin);
scanf("%d",&n);
memset(g,0,sizeof(g));
for(i=1; i<n; i++)
{
scanf("%d%d",&a,&b);
p=new Node;
p->next=g[a].next;
p->v=b;
g[a].next=p;
p=new Node;
p->next=g[b].next;
p->v=a;
g[b].next=p;
}
memset(mark,false,sizeof(mark));
memset(c,0,sizeof(c));
for(i=1; i<=n; i++)
flag[i]=1;
cnt=0;
dfs(1);
scanf("%d",&m);
while(m--)
{
scanf("%s",temp);
if(temp[0] == 'Q')
{
scanf("%d",&a);
ans=high[a]-low[a]+1+Sum(high[a])-Sum(low[a]-1);
printf("%d\n",ans);
}
else
{
scanf("%d",&a);
if(flag[a]) Modify(low[a],-1);
else Modify(low[a],1);
flag[a]^=1;
}
}
return 0;
}

(3)http://acm.pku.edu.cn/JudgeOnline/problem?id=2481
给n个区间[Si,Ei]，区间[Sj,Ej]< [Si,Ei] 有 Si <= Sj and Ej <= Ei and Ei - Si > Ej – Sj。按y坐标从小到达，x坐标从大到小的顺序排序，然后从后往前扫描，记录i之前所有的j区间Sj<Si的个数，这个用树状数组实现。扫描一遍可得出结果。

Cpp代码

#include <stdio.h>
#include <string>
#include <algorithm>
using namespace std;
struct P
{
int x,y,id;
}p[100005];
int n,a[100005],max_n,b[100005];
int lowbit(int k)
{
return k&(-k);
}
void Modify(int num, int v)
{
while(num <= max_n)
{
a[num]+=v;
num+=lowbit(num);
}
}
int Sum(int num)
{
int ans=0;
if(num <= 0) return 0;
while(num)
{
ans+=a[num];
num-=lowbit(num);
}
return ans;
}
bool operator <(const P a, const P b)
{
if(a.y == b.y) return a.x > b.x;
return a.y < b.y;
}
int main()
{
int i;
//freopen("in.txt","r",stdin);
while(scanf("%d",&n), n)
{
max_n=0;
for(i=0; i<n; i++)
{
scanf("%d%d",&p[i].x,&p[i].y);
p[i].id=i;
p[i].x++;
p[i].y++;
if(p[i].y > max_n) max_n=p[i].y;
}
sort(p,p+n);
memset(a,0,sizeof(a));
for(i=n-1; i>=0; i--)
{
if(i != n-1 && p[i].y == p[i+1].y && p[i].x == p[i+1].x)
b[p[i].id]=b[p[i+1].id];
else
b[p[i].id]=Sum(p[i].x);
Modify(p[i].x,1);
}
for(i=0; i<n; i++)
{
if(i) printf(" ");
printf("%d",b[i]);
}
printf("\n");
}
return 0;
}

(4)用树状数组求区间第K小元素
算法的时间复杂度是O(log(n))的，如果要求在线计算的话显然很有优势。
基本思路是：
先开一个数组，其中记录某个数出现次数，每输入一个树，相当于将该数出现次数加1，对应到树状数组中就相当于insert(t, 1),统计的时候，可以利用树状数组的求和，既可以二分枚举，也可以利用数的二进制表示，下面的代码有效地利用了数的二进制表示。

Cpp代码

#include <iostream>
using namespace std;
#define maxn 1<<20
int n,k;
int c[maxn];
int lowbit(int x){
return x&-x;
}
void insert(int x,int t){
while(x<maxn){
c[x]+=t;
x+=lowbit(x);
}
}
int find(int k){
int cnt=0,ans=0;
for(int i=20;i>=0;i--){
ans+=(1<<i);
if(ans>=maxn || cnt+c[ans]>=k)ans-=(1<<i);
else cnt+=c[ans];
}
return ans+1;
}
void input(){
memset(c,0,sizeof(c));
int t;
scanf("%d%d",&n,&k);
for(int i=0;i<n;i++){
scanf("%d",&t);
insert(t,1);
}
printf("%d\n",find(k));
}
int main(){
int cases;
scanf("%d",&cases);
while(cases--){
input();
}
return 0;
}

高达一号

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
链表/树 - 线段树，树状数组

线段树博客分类：算法线段树的构造思想线段树是一棵二叉树，树中的每一个结点表示了一个区间[a,b]。每一个叶子节点表示了一个单位区间。对于每一个非叶结点所表示的结点[a,b]，其左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2,b]。例如: 线段树的运用线段树的每个节点上往往都增加了一些其他的域。在这些域中保存了某种动态维护的信息，视不同情况而定...
复制链接

扫一扫