树状数组原理和代码

news2024/11/17 13:56:33

树状数组

求下标的对应

求i管着的下标的范围

方法：拆掉最右侧的1然后+1  到你自己

query sum

1-i的和

拆掉最右侧的1 再把下一个数值吸收到sum 重复这个过程直到全变0为止

add

方法：加上最右侧的1 到上限为止

lowbit方法

单点增加范围查询模板

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include<vector>
#include<climits>
#include<cmath>
using namespace std;
typedef long long LL;
const int N=5e5+10;
int tree[N];
int n,m;

int lowbit(int i){
	return i&-i;
}

void add(int i,int v){
	while(i<=n){
		tree[i]+=v;
		i+=lowbit(i);
	}
}

int sum(int i){
	int ans=0;
	while(i>0){
		ans+=tree[i];
		i-=lowbit(i);
	}
	return ans;
}

int range(int l,int r){
	return sum(r)-sum(l-1);
}

int main() {
    ios::sync_with_stdio(false); // 可选的，用于加快I/O
    cin.tie(0);
    while (cin >> n >> m) {
        for (int i = 1, v; i <= n; i++) {
            cin >> v;
            add(i, v);
        }
        for (int i = 1, a, b, c; i <= m; i++) {
            cin >> a >> b >> c;
            if (a == 1) {
                add(b, c);
            } else {
                cout << range(b, c) << '\n';
            }
        }
    }
    return 0;
}

范围增加单点查询的模板

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include<vector>
#include<climits>
#include<cmath>
using namespace std;
typedef long long LL;
const int N=5e5+10;
int tree[N];
int n,m;

int lowbit(int i){
	return i&-i;
}

void add(int i,int v){
	while(i<=n){
		tree[i]+=v;
		i+=lowbit(i);
	}
}

int sum(int i){
	int ans=0;
	while(i>0){
		ans+=tree[i];
		i-=lowbit(i);
	}
	return ans;
}

int range(int l,int r){
	return sum(r)-sum(l-1);
}

int main() {
    
    while (cin >> n >> m) {
        for (int i = 1, v; i <= n; i++) {
            cin >> v;
            add(i, v);
            add(i + 1, -v);
        }
        for (int i = 1; i <= m; i++) {
            int op;
            cin >> op;
            if (op == 1) {
                int l, r, v;
                cin >> l >> r >> v;
                add(l, v);
                add(r + 1, -v);
            } else {
                int index;
                cin >> index;
                cout << sum(index) << '\n';
            }
        }
    }
    return 0;
}

树状数组实现范围增加范围查询

#include <iostream>
using namespace std;

const int MAXN = 100001;
long long info1[MAXN]; // 维护原始数组的差分信息：Di
long long info2[MAXN]; // 维护原始数组的差分加工信息：(i-1) * Di
int n, m;

int lowbit(int i) {
    return i & -i;
}

void add(long long tree[], int i, long long v) {
    while (i <= n) {
        tree[i] += v;
        i += lowbit(i);
    }
}

long long sum(long long tree[], int i) {
    long long ans = 0;
    while (i > 0) {
        ans += tree[i];
        i -= lowbit(i);
    }
    return ans;
}

void rangeAdd(int l, int r, long long v) {
    add(info1, l, v);
    add(info1, r + 1, -v);
    add(info2, l, (l - 1) * v);
    add(info2, r + 1, -(r * v));
}

long long rangeQuery(int l, int r) {
    return sum(info1, r) * r - sum(info2, r) - sum(info1, l - 1) * (l - 1) + sum(info2, l - 1);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    cin >> n >> m;
    long long cur;
    for (int i = 1; i <= n; ++i) {
        cin >> cur;
        rangeAdd(i, i, cur);
    }
    int op, l, r;
    long long v;
    for (int i = 1; i <= m; ++i) {
        cin >> op;
        if (op == 1) {
            cin >> l >> r >> v;
            rangeAdd(l, r, v);
        } else {
            cin >> l >> r;
            cout << rangeQuery(l, r) << '\n';
        }
    }

    return 0;
}

相关题目

逆序对

归并分治法

#include <iostream>
#include <vector>
using namespace std;

const int MAXN = 500001;
int arr[MAXN];
int help[MAXN];
int n;
long long merge(int l, int m, int r);

long long f(int l, int r) {
    if (l == r) {
        return 0;
    }
    int m = (l + r) / 2;
    return f(l, m) + f(m + 1, r) + merge(l, m, r);
}

long long merge(int l, int m, int r) {
    long long ans = 0;
    // 统计逆序对数量
    for (int i = m, j = r; i >= l; i--) {
        while (j >= m + 1 && arr[i] <= arr[j]) {
            j--;
        }
        ans += j - m;
    }
    // 归并排序，让arr[l...r]变成有序
    int i = l, a = l, b = m + 1;
    while (a <= m && b <= r) {
        help[i++] = arr[a] <= arr[b] ? arr[a++] : arr[b++];
    }
    while (a <= m) {
        help[i++] = arr[a++];
    }
    while (b <= r) {
        help[i++] = arr[b++];
    }
    for (i = l; i <= r; i++) {
        arr[i] = help[i];
    }
    return ans;
}

int main() {
   

    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> arr[i];
    }

    cout << f(1, n) << '\n';
    return 0;
}

树状数组解法

去重+离散化

#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 500001;
int arr[MAXN];
int sortArr[MAXN]; // 用于排序和去重的数组
int tree[MAXN]; // 树状数组
int n, m; // n为数组长度，m为离散化后的值域大小

int lowbit(int x) {
    return x & (-x);
}

void add(int idx, int val) {
    while (idx <= m) {
        tree[idx] += val;
        idx += lowbit(idx);
    }
}

long long sum(int idx) {
    long long res = 0;
    while (idx > 0) {
        res += tree[idx];
        idx -= lowbit(idx);
    }
    return res;
}

// 离散化函数，将数组arr中的值映射到1~m
void discretization() {
    sort(sortArr + 1, sortArr + n + 1);
    m = unique(sortArr + 1, sortArr + n + 1) - (sortArr + 1); // unique返回去重后的尾后迭代器
    for (int i = 1; i <= n; ++i) {
        arr[i] = lower_bound(sortArr + 1, sortArr + m + 1, arr[i]) - sortArr;
    }
}

long long compute() {
    long long ans = 0;
    for (int i = n; i >= 1; --i) {
        ans += sum(arr[i] - 1);
        add(arr[i], 1);
    }
    return ans;
}

int main() {
    ios::sync_with_stdio(false); // 关闭同步
    cin.tie(0); // 解除cin和cout的绑定
    cout.tie(0);

    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> arr[i];
        sortArr[i] = arr[i];
    }

    discretization(); // 离散化处理
    cout << compute() << endl; // 计算逆序对数量并输出

    return 0;
}

上升三元组

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int MAXN = 30001;
int arr[MAXN], sortArr[MAXN];
long long tree1[MAXN], tree2[MAXN];
int n, m;

int lowbit(int i) {
    return i & -i;
}

void add(long long tree[], int i, long long c) {
    while (i <= m) {
        tree[i] += c;
        i += lowbit(i);
    }
}

long long sum(long long tree[], int i) {
    long long ans = 0;
    while (i > 0) {
        ans += tree[i];
        i -= lowbit(i);
    }
    return ans;
}

long long compute() {
    copy(arr + 1, arr + n + 1, sortArr + 1);
    sort(sortArr + 1, sortArr + n + 1);
    m = unique(sortArr + 1, sortArr + n + 1) - (sortArr + 1);
    for (int i = 1; i <= n; i++) {
        // Using lower_bound to replace the manual rank function
        arr[i] = lower_bound(sortArr + 1, sortArr + m + 1, arr[i]) - sortArr;
    }
    long long ans = 0;
    for (int i = 1; i <= n; i++) {
        ans += sum(tree2, arr[i] - 1);
        add(tree1, arr[i], 1);
        add(tree2, arr[i], sum(tree1, arr[i] - 1));
    }
    return ans;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> arr[i];
    }
    cout << compute() << endl;
    return 0;
}

最长递增子序列个数

673. 最长递增子序列的个数

#include <vector>
#include <algorithm>
#include <numeric> // 用于iota函数
using namespace std;

class Solution {
public:
    static const int MAXN = 2001; // 设置最大数值范围
    vector<int> treeMaxLen = vector<int>(MAXN, 0); // 以数值i结尾的最长递增子序列的长度
    vector<int> treeMaxLenCnt = vector<int>(MAXN, 0); // 以数值i结尾的最长递增子序列的个数
    int m; // 数组去重排序后的长度

    int lowbit(int i) {
        return i & (-i);
    }

    void query(int i, int& maxLen, int& maxLenCnt) {
        maxLen = maxLenCnt = 0;
        while (i > 0) {
            if (treeMaxLen[i] == maxLen) {
                maxLenCnt += treeMaxLenCnt[i];
            } else if (treeMaxLen[i] > maxLen) {
                maxLen = treeMaxLen[i];
                maxLenCnt = treeMaxLenCnt[i];
            }
            i -= lowbit(i);
        }
    }

    void add(int i, int len, int cnt) {
        while (i <= m) {
            if (treeMaxLen[i] == len) {
                treeMaxLenCnt[i] += cnt;
            } else if (treeMaxLen[i] < len) {
                treeMaxLen[i] = len;
                treeMaxLenCnt[i] = cnt;
            }
            i += lowbit(i);
        }
    }

    int findNumberOfLIS(vector<int>& nums) {
    if (nums.empty()) return 0;
    vector<int> sortedNums(nums.begin(), nums.end());
    sort(sortedNums.begin(), sortedNums.end());
    auto it = unique(sortedNums.begin(), sortedNums.end()); // 去重，it指向去重后新的末尾
    m = distance(sortedNums.begin(), it); // 使用迭代器之间的距离作为去重后数组的长度

    // 根据去重后的长度调整树状数组的大小
    treeMaxLen.assign(m + 1, 0);
    treeMaxLenCnt.assign(m + 1, 0);

    for (int num : nums) {
        // 注意这里的lower_bound的范围，应当是begin()到it
        int i = lower_bound(sortedNums.begin(), it, num) - sortedNums.begin() + 1; // 获取排名（1-based）
        int maxLen, maxLenCnt;
        query(i - 1, maxLen, maxLenCnt);
        add(i, maxLen + 1, maxLenCnt == 0 ? 1 : maxLenCnt);
    }
    int totalMaxLen = 0, totalCount = 0;
    query(m, totalMaxLen, totalCount);
    return totalCount;
}

};

P1972 [SDOI2009] HH的项链

每种颜色只留最右边的

#include <iostream>
#include <algorithm>
#include <vector>
#include <cstdio>

using namespace std;

const int MAXN = 1000010;
int arr[MAXN], ans[MAXN], map[MAXN], tree[MAXN], n, m;

struct Query {
    int l, r, idx;
    Query(int l = 0, int r = 0, int idx = 0) : l(l), r(r), idx(idx) {}
};

vector<Query> queries(MAXN);

int lowbit(int i) {
    return i & -i;
}

void add(int i, int v) {
    while (i <= n) {
        tree[i] += v;
        i += lowbit(i);
    }
}

int sum(int i) {
    int ans = 0;
    while (i > 0) {
        ans += tree[i];
        i -= lowbit(i);
    }
    return ans;
}

int range(int l, int r) {
    return sum(r) - sum(l - 1);
}

void compute() {
    sort(queries.begin() + 1, queries.begin() + m + 1, [](const Query& a, const Query& b) {
        return a.r < b.r;
    });
    for (int s = 1, q = 1; q <= m; q++) {
        int r = queries[q].r;
        for (; s <= r; s++) {
            if (map[arr[s]] != 0) {
                add(map[arr[s]], -1);
            }
            add(s, 1);
            map[arr[s]] = s;
        }
        ans[queries[q].idx] = range(queries[q].l, r);
    }
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &arr[i]);
    }
    scanf("%d", &m);
    for (int i = 1; i <= m; i++) {
        int l, r;
        scanf("%d %d", &l, &r);
        queries[i] = Query(l, r, i);
    }
    compute();
    for (int i = 1; i <= m; i++) {
        printf("%d\n", ans[i]);
    }
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1541951.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

[leetcode] 240. 搜索二维矩阵 II

[leetcode] 240. 搜索二维矩阵 II

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性&#xff1a; 每行的元素从左到右升序排列。每列的元素从上到下升序排列。 示例 1&#xff1a; 输入&#xff1a;matrix [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,…
阅读更多...
从抛硬币试验看概率论的基本内容及统计方法

从抛硬币试验看概率论的基本内容及统计方法

一般说到概率&#xff0c;就喜欢拿抛硬币做例子。大多数时候&#xff0c;会简单认为硬币正背面的概率各为二分之一&#xff0c;其实事情远没有这么简单。这篇文章会以抛硬币试验为例子并贯穿全文&#xff0c;引出一系列概率论和数理统计的基本内容。这篇文章会涉及的有古典概型…
阅读更多...
Java实现JDBC编程

Java实现JDBC编程

1 数据库编程的必备条件 编程语言&#xff0c;如Java&#xff0c;C、C、Python等 数据库&#xff0c;如Oracle&#xff0c;MySQL&#xff0c;SQL Server等 数据库驱动包&#xff1a;不同的数据库&#xff0c;对应不同的编程语言提供了不同的数据库驱动包&#xff0c;如&#x…
阅读更多...
【Linux】对进程地址空间的理解

【Linux】对进程地址空间的理解

一、关于进程地址空间的简单理解 进程地址空间其实是分了很多个区域的&#xff0c;区域划分的本质就是区域内的各个地址都是可以使用的。如同下面这个图所示&#xff1a; 无论是环境变量的地址还是环境变量表的地址&#xff0c;所存放的地址都在栈的上部。这里的已初始化数据和…
阅读更多...
java多线程编程面试题总结

java多线程编程面试题总结

一些最基本的基础知识就不总结了&#xff0c;参考之前写的如下几篇博客&#xff0c;阅读顺序从上到下&#xff0c;依次递进。 java 多线程 多线程概述及其三种创建方式 线程的常用方法 java 线程安全问题 三种线程同步方案 线程通信&#xff08;了解&#xff09; java 线程池…
阅读更多...
JavaEE企业级分布式高级架构师课程

JavaEE企业级分布式高级架构师课程

教程介绍 本课程主要面向1-5年及以上工作经验的Java工程师&#xff0c;大纲由IT界知名大牛 — 廖雪峰老师亲自打造&#xff0c;由来自一线大型互联网公司架构师、技术总监授课&#xff0c;内容涵盖深入spring5设计模式/高级web MVC开发/高级数据库设计与开发/高级响应式web开发…
阅读更多...
arm作业3

arm作业3

key_inc.c #include"key_inc.h"void key1_it_config(){//使能GPIOF外设时钟RCC->MP_AHB4ENSETR | (0x1<<5);//将PF9设置为输入模式GPIOF->MODER & (~(0x3<<18));//设置由PF9管脚产生EXTI9事件EXTI->EXTICR3 & (~(0XFF<<8));EXTI-…
阅读更多...
微服务（基础篇-002-Ribbon）

微服务（基础篇-002-Ribbon）

目录 Ribbon负载均衡&#xff08;1&#xff09; 负载均衡的原理&#xff08;1.1&#xff09; 负载均衡策略&#xff08;1.2&#xff09; Ribbon-IRule(1.2.1) 修改负载均衡的方法&#xff08;1.2.2&#xff09; 懒加载&#xff08;1.3&#xff09; 饥饿加载&#xff08;1…
阅读更多...
【Linux】模拟实现shell（bash）

【Linux】模拟实现shell（bash）

目录 常见的与shell互动场景 实现代码 全部代码 homepath()接口 const char *getUsername()接口 const char *getHostname()接口 const char *getCwd()接口 int getUserCommand(char *command, int num)接口 void commandSplit(char *in, char *out[])接口 int execut…
阅读更多...
python每日可视化分析：从过去到现代数据分析的演进

python每日可视化分析：从过去到现代数据分析的演进

分析目标 本文旨在探索数据分析发展历程中的关键时刻&#xff0c;包括重要人物的贡献和大事件的发生。通过对比不同年代的数据分析技术和方法&#xff0c;我们可以更好地理解数据分析如何成为今天决策制定不可或缺的一部分。 分析步骤 收集数据&#xff1a;搜集关于数据分析历…
阅读更多...
【Redis】优惠券秒杀

【Redis】优惠券秒杀

全局唯一ID 全局唯一ID生成策略&#xff1a; UUIDRedis自增snowflake算法数据库自增 Redis自增ID策略&#xff1a;每天一个key&#xff0c;方便统计订单量ID构造是 时间戳 计数器 Component public class RedisIdWorker {// 2024的第一时刻private static final long BEGIN…
阅读更多...
微服务（基础篇-001-介绍、Eureka）

微服务（基础篇-001-介绍、Eureka）

目录 认识微服务&#xff08;1&#xff09; 服务架构演变&#xff08;1.1&#xff09; 单体架构&#xff08;1.1.1&#xff09; 分布式架构&#xff08;1.1.2&#xff09; 微服务&#xff08;1.1.3&#xff09; 微服务结构 微服务技术对比 企业需求 SpringCloud(1.2) …
阅读更多...
[BIT]智慧社区综合管理云平台需求文档

[BIT]智慧社区综合管理云平台需求文档

智慧社区综合管理云平台需求文档 目录: 智慧社区综合管理云平台需求文档一、 项目前景和范围文档1.业务需求1.1 项目前景1.2 主要特性1.2.1 安全监控1.2.2 社区服务1.2.3 电子化档案 1.3 假设与依赖 2.项目范围2.1 功能实现2.2 验收标准2.3 可交付成果2.4 项目的除外责任2.5 制…
阅读更多...
基于SpringBoot+Vue+Mybatis的408刷题小程序管理端

基于SpringBoot+Vue+Mybatis的408刷题小程序管理端

简介 原始数据&#xff1a;书目信息、章节信息、题目信息、系统菜单、系统角色、系统用户。 主要任务&#xff1a;系统主要采用spring boot作为后端框架&#xff0c;前端使用vueelementUI&#xff0c;为408刷题小程序提供一个方面的管理和维护的任务&#xff0c;主要功能包括…
阅读更多...
centos glibc 升级导致系统崩溃

centos glibc 升级导致系统崩溃

centos 7.9默认的glibc为2.17&#xff0c;因为要安装一些软件&#xff0c;需要升级到glibc 2.18&#xff0c;而从源码进行编译和安装&#xff0c;安装失败&#xff0c;导致系统崩溃。 系统崩溃首先想到的是利用启动盘进行救援&#xff0c;而利用centos 7.9的启动盘始终无法挂载…
阅读更多...
AI：152- 利用深度学习进行手势识别与控制

AI：152- 利用深度学习进行手势识别与控制

本文收录于专栏：精通AI实战千例专栏合集 从基础到实践，深入学习。无论你是初学者还是经验丰富的老手，对于本专栏案例和项目实践都有参考学习意义。 每一个案例都附带关键代码，详细讲解供大家学习，希望可以帮到大家。正在不断更新中~ 一. 利用深度学习进行手势识别与控制 …
阅读更多...
jetcache 2级缓存模式实现批量清除

jetcache 2级缓存模式实现批量清除

需求 希望能够实现清理指定对象缓存的方法&#xff0c;例如缓存了User表&#xff0c;当User表巨大时&#xff0c;通过id全量去清理不现实&#xff0c;耗费资源也巨大。因此需要能够支持清理指定本地和远程缓存的批量方法。 分析 查看jetcache生成的cache接口&#xff0c;并没…
阅读更多...
nodejs+vue高校失物招领平台python-flask-django-php

nodejs+vue高校失物招领平台python-flask-django-php

时代在飞速进步&#xff0c;每个行业都在努力发展现在先进技术&#xff0c;通过这些先进的技术来提高自己的水平和优势&#xff0c;高校失物招领平台当然不能排除在外。高校失物招领平台是在实际应用和软件工程的开发原理之上&#xff0c;运用nodejs语言以及express框架进行开发…
阅读更多...
如何在 Django 中使用 pyecharts

如何在 Django 中使用 pyecharts

为项目新建一个目录&#xff0c;将其命名为django_pyecharts_demo, 在终端中切换到这个目录&#xff0c;并创建一个虚拟环境。 python -m venv django_pyecharts激活虚拟环境 django_pyecharts\Scripts\activate要停止使用虚拟环境&#xff0c;可执行命令 deactivate创建并激…
阅读更多...
音视频领域首个，阿里云推出华为鸿蒙 HarmonyOS NEXT 版音视频 SDK

音视频领域首个，阿里云推出华为鸿蒙 HarmonyOS NEXT 版音视频 SDK

近日&#xff0c;阿里云在官网音视频终端 SDK 栏目发布适配 HarmonyOS NEXT 的操作文档和 SDK&#xff0c;官宣 MediaBox 音视频终端 SDK 全面适配 HarmonyOS NEXT。 此外&#xff0c;阿里云播放器 SDK 也在华为开发者联盟官网鸿蒙生态伙伴 SDK 专区同步上线&#xff0c;面向所…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023