区间信息的维护与查询（稀疏表、线段树等） 简单介绍

目录

1. RMQ问题-稀疏表
2. 线段树
3. 树状数组

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;
}

例题和解析

UVa-11235

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);
}