目录
1.RMQ问题-稀疏表
目录
范围最小值问题(RMQ):给出一段区间,求这段区间上的最值。
采用线段树的话,建树的复杂度为O(n),而查询的复杂度为O(logn)。
采用稀疏表的话,预处理的复杂度为O(nlogn),但是查询的复杂度可以降到O(1)。
如果查询的次数较多,采用稀疏表更合适,并且稀疏表的代码量远小于线段树。
大致介绍
稀疏表采用类似动态规划的方式,用dp[i][j]表示从第i个数据开始,长度为2 ^ j的区间中的最值。当查询区间[a,b]时,令len等于区间长度,2^k为不大于len的最大长度,然后选取以i为起点和以j为终点,长度均为2 ^ k的两段区间中符合的最值即可(如图)。
模板
#include <bits/stdc++.h>
#define MAXN 100000
using namespace std;
int dp[MAXN][15];
int data[MAXN];
int length;
//预处理dp,区间最小值
void init()
{
for (int i = 0; i < length; i++)
dp[i][0] = data[i];
for (int k = 1; (1 << k) <= length; k++)
{
int len1 = 1 << k; //当前区间长度
int len2 = len1 >> 1; //当前区间长度的一半
for (int j = 0; j + len1 - 1 < length; j++)
//如果下标从1开始改为:for (int j = 1; j + len1 - 1 <= length; j++)
{
dp[j][k] = min(dp[j][k - 1], dp[j + len2][k - 1]);
}
}
}
//查询区间[l,r]的最小值
int query(int l, int r)
{
int k = 0, len = r - l + 1;
while (len >= 2)
k++, len >>= 1;
return min(dp[l][k], dp[r - tp[k] + 1][k]);
}
int main()
{
//...
return 0;
}
例题和解析
2.线段树
目录
大致介绍
线段树是一种工具而不是一种算法,主要对于区间问题进行优化,使其复杂度由O(n)降为O(logn),能够使用线段树的问题一般能转换成一些连续点的修改和统计问题。
模板
线段树主要由四大函数构成:build、pushdown、update、query。
//线段树模板
#include <bits/stdc++.h>
#define MAXN 100000 //数据量
using namespace std;
struct node
{
int l, r;
int val = 0, lazy = 0;
} nd[MAXN * 4]; //下标从1开始
int data[MAXN]; //输入数据,下标从0开始
//递归建树
void build_tree(int root, int l, int r)
{
nd[root].l = l;
nd[root].r = r;
if (l == r)
{
nd[root].val = data[l];
return;
}
int mid = (l + r) >> 1;
build_tree(root << 1, l, mid);
build_tree(root << 1 | 1, mid + 1, r);
nd[root].val = nd[root << 1].val + nd[root << 1 | 1].val;
}
//非递归建树,适用于数据量特别大的时候
void build_tree(int size)
{
int length = 1;
while (length < size)
length <<= 1;
for (int i = length + size - 1; i >= length; i--)
{
nd[i].val = data[i - length];
nd[i].l = i - length;
nd[i].r = i - length;
}
for (int root = length - 1; root >= 1; root--)
{
nd[root].l = root << 1;
nd[root].r = root << 1 | 1;
nd[root].val = nd[root << 1].val + nd[root << 1 | 1].val;
}
}
//lazy标记下传
inline void pushdown(int root)
{
if (nd[root].lazy != 0)
{
nd[root << 1].lazy += nd[root].lazy;
nd[root << 1].val += (nd[root << 1].r - nd[root << 1].l + 1) * nd[root].lazy;
nd[root << 1 | 1].lazy += nd[root].lazy;
nd[root << 1 | 1].val += (nd[root << 1 | 1].r - nd[root << 1 | 1].l + 1) * nd[root].lazy;
nd[root].lazy = 0;
}
}
//区间更新
void update(int l, int r, int val, int root = 1)
{
if (l <= nd[root].l && r >= nd[root].r)
{
nd[root].lazy += val;
nd[root].val += (nd[root].r - nd[root].l + 1) * val;
return;
}
pushdown(root); //每次更新前需要将lazy标记下传
int mid = nd[root].l + nd[root].r >> 1;
if (l <= mid)
update(l, mid, val, root << 1);
if (r > mid)
update(mid + 1, r, val, root << 1 | 1);
nd[root].val = nd[root << 1].val + nd[root << 1 | 1].val;
}
//区间查询
int query(int l, int r, int root = 1)
{
if (l <= nd[root].l && r >= nd[root].r)
return nd[root].val;
pushdown(root);
int mid = nd[root].l + nd[root].r >> 1;
if (r <= mid)
return query(l, r, root << 1);
if (l > mid)
return query(l, r, root << 1 | 1);
return query(l, mid, root << 1) + query(mid + 1, r, root << 1 | 1);
}
int main()
{
//...
return 0;
}
简单讲解
关于lazy标志:
如果要修改的区间完全包含当前结点的区间,只要对这个结点打一个标记就行,而不用将下面所有的结点一并修改。如果下次查询到这个结点的子树时,将lazy标志下传到子树即可,因为lazy标志只影响子树,对父结点没有影响,所以只要把lazy标志下传到要查询的结点位置就可以避免其影响。
因此,在区间修改和区间查询的时候,进入子树之前需要先进行pushdown操作。
例题和解析
LA3938 前后缀和
PAT森森快递 贪心加标记
UVA11992 双重区间标记 矩阵运算
ICPC2021网络赛真题
3.树状数组
目录
大致介绍
树状数组是线段树的简化版,代码量大大减少,但是实现的功能也相应地减少了,可以说树状数组能实现的功能线段树都能实现,但是线段树的一些功能无法用树状数组来实现。树状数组的查询复杂度也是O(logn)级别的,但是比线段树更快。
树状数组分为A数组和C数组,A数组存储数据,C数组存储区间和。
C[n]=A[n-lowbit(n)+1]+A[n-lowbit(n)+2]+...+A[n]
lowbit(n)为n的二进制中最低位的1 //比如lowbit(01100)=00100
lowbit的实现方式为n&(-n) //跟补码有关
模板
树状数组支持单点修改、前缀和查询两种操作,区间和的查询是由两次前缀和相减得来
前缀和查询操作(前x个):每次加C[x]后将x减去lowbit(x),直到x为0
单点修改x:每次将x加上lowbit(x),修改对应的C,直到x大于n
inline int lowbit(int x)
{
return x&(-x);
}
//单点修改
void update(int x, int value)
{
A[x] += value;
while(x <= n)
{
C[x] += value;
x += lowbit(x);
}
}
//前缀和查询
int presum(int x)
{
int res = 0;
while(x > 0){
res += c[x];
x -= lowbit(x);
}
return res;
}
//区间和查询
inline int query(int l,int r)
{
return presum(r)-presum(l-1);
}