線段樹和樹狀數組 (筆記)

最新推荐文章于 2022-10-22 22:16:35 发布
最新推荐文章于 2022-10-22 22:16:35 发布
阅读量112 收藏
点赞数
分类专栏： 算法筆記 线段树 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58286631/article/details/125118263
版权

单点修改和区间求和的模板

luogu P3374

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
#define MOD 1000000007
using namespace std;
typedef long long ll;
int n, m;
int a[1000000];
int v[4000000];
void build(int x, int l, int r){
	if(l == r){
		v[x] = a[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(x<<1, l, mid);
	build(x<<1|1, mid + 1, r);
	v[x] = v[x<<1] + v[x<<1|1];
}
//y is the node you want to modify
void modify(int x, int l, int r, int y, int z){
	if(l == r){
		v[x] += z;
		return ;
	}
	int mid = (l + r)>>1;
	if(y <= mid){
		modify(x<<1, l, mid, y, z);
	}
	else{
		modify(x<<1|1, mid+1, r, y, z);
	}
	v[x] = v[x<<1]+v[x<<1|1];
}
ll query(int x, int l, int r, int ql, int qr){
	if(l == ql && r == qr){
		return v[x];
	}
	int mid = (l + r)>>1;
	if(ql <= mid && qr>mid){
		return query(x<<1, l, mid, ql, mid) + 
				query(x<<1|1, mid + 1, r, mid + 1, qr);
	}
	else if(qr <= mid){
		return query(x<<1, l, mid, ql, qr);
	}
	else{
		return query(x<<1|1, mid + 1, r, ql, qr);
	}
}
int main(){
	cin >> n >> m;
	for(int i = 1; i <= n; i++){
		cin >> a[i];
	}
	build(1, 1, n);
	int l, r, k;
	while(m--){
		cin >> k >> l >> r;
		if(k == 1){
			modify(1, 1, n, l, r);
		}else{
			cout << query(1, 1, n, l, r) << endl;
		}
	}
	return 0;
}

也可以用来求LCA.

leetcode 236 

class Solution {
public:
    map<int, TreeNode*> a;
    int atop = 0;
    map<TreeNode*, int> b;
    map<TreeNode*, int> dp;
    TreeNode* v[610000];
    void dfs(TreeNode* root){
	    if(!root)return;
        a[++atop] = root;
        b[root] = atop;
        if(root->left){
            dp[root->left] = dp[root] + 1;
            dfs(root->left);
            a[++atop] = root;
        }
        if(root->right){
            dp[root->right] = dp[root] + 1;
            dfs(root->right);
            a[++atop] = root;            
        }
    }
    TreeNode* cmp(TreeNode* x, TreeNode* y){
        if(dp[x] < dp[y])return x;
        return y;
    }
    void build(int x, int l, int r){
        if(l == r){
            v[x] = a[l];
            return;
        }
        int mid = (l + r) >> 1;
        build(x<<1, l, mid);
        build(x<<1|1, mid + 1, r);
        v[x] = cmp(v[x<<1], v[x<<1|1]);
    }
    TreeNode* query(int x, int l, int r, int ql, int qr){
        if(l == ql && r==qr){
            return v[x];
        }
        int mid = (l + r) >> 1;
        if(ql <= mid && mid < qr){
            return cmp(query(x<<1, l, mid, ql, mid),
                      query(x<<1|1, mid+1, r, mid + 1, qr));
        }
        else if(qr <= mid){
            return query(x<<1,l,mid, ql, qr);
        }
        else{
            return query(x<<1|1, mid+1, r, ql, qr);
        }
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        dfs(root);
        build(1, 1, atop);
        if(b[p] > b[q]){
            return query(1, 1, atop, b[q], b[p]);
        }else{
            return query(1, 1, atop, b[p], b[q]);            
        }
    
    }
};

luogu P3379 求LCA 

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
#define MOD 1000000007
using namespace std;
typedef long long ll;
int n, m, o;
struct edge{
	int next, y;
}e[1100000];
int link[510000], ltop = 0;
void insert(int x, int y){
	e[++ltop]= (edge){link[x], y};
	link[x] = ltop;
	e[++ltop] = (edge){link[y], x};
	link[y] = ltop;
}
int a[1100000], atop = 0;
int b[510000];
int dp[510000];
int v[4100000];
void dfs(int x, int y){
	a[++atop] = x;
	b[x] = atop;
	for(int i = link[x]; i; i=e[i].next){
		if(e[i].y == y)continue;
		dp[e[i].y] = dp[x] + 1;
		dfs(e[i].y, x);
		a[++atop] = x;
	}
}
int cmp(int x, int y){
	if(dp[x] < dp[y])return x;
	return y;
}
void build(int x, int l, int r){
	if(l == r){
		v[x] = a[l];
		return ;
	}
	int mid = (l + r) >> 1;
	build(x<<1, l, mid);
	build(x<<1|1, mid + 1, r);
	v[x] = cmp(v[x<<1], v[x<<1|1]);
}
int query(int x, int l, int r, int ql, int qr){
	if(l == ql && r == qr){
		return v[x];
	}
	int mid = (l + r) >> 1;
	if(ql <= mid && mid < qr){
		return cmp(query(x<<1, l, mid, ql, mid),
					query(x<<1|1, mid + 1, r, mid + 1, qr));
	}
	else if(qr<=mid){
		return query(x<<1, l, mid, ql, qr);
	}
	else{
		return query(x<<1|1, mid + 1, r, ql, qr);
	}
}
int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	
	cin >> n >> m >> o;
	int l, r;
	for(int i = 1; i < n; i++){
		cin >> l >> r;
		insert(l, r);
	}
	dfs(o, 0);
	build(1, 1, atop);
	while(m-- > 0){
		cin >> l >> r;
		if(b[l] > b[r]){
			swap(l, r);
		}
		cout << query(1, 1, atop, b[l], b[r]) << endl;
	}
	return 0;
}

整体区间修改.

P3373

这一题有乘法修改和加法修改, 要弄两个懒标签数组, 一个应对乘法, 一个应对加法.

当有乘法的修改时, 我们要把加法的懒标签一并变大同等倍数, 但是加法操作的时候不需要帮乘法懒标签加上, 因为乘法标签只记录倍数, 而这个倍数对加法操作有影响.

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
using namespace std;
typedef long long ll;
ll MOD;
int n, m;
vector<ll> a(110000, 0);
vector<ll> v(410000, 0);
vector<ll> d1(410000, 1);
vector<ll> d2(410000, 0);
void build(int x, int l, int r){
	if(l == r){
		v[x] = a[l];
		return;
	}
	int mid = (l + r)>>1;
	build(x<<1, l, mid);
	build(x<<1|1, mid + 1, r);
	v[x] = (v[x<<1] + v[x<<1|1]) % MOD;
}
void mutiplyd(int x, ll z){
	d1[x] = d1[x] * z % MOD;
	d2[x] = d2[x] * z % MOD;
	v[x] = v[x] * z % MOD;
}
void plusd(int x, int l, int r, ll z){
	d2[x] = (d2[x] + z) % MOD;
	v[x] = (v[x] + z * (r - l + 1)) % MOD;
}
void pushdown(int x, int l, int r, int mid){
	if(d1[x] != 1){
		mutiplyd(x<<1, d1[x]);
		mutiplyd(x<<1|1, d1[x]);
		d1[x] = 1;
	}
	if(d2[x] != 0){
		plusd(x<<1, l, mid, d2[x]);
		plusd(x<<1|1, mid + 1, r, d2[x]);
		d2[x] = 0;
	}
}
//y is the operation 1 is mutiply 2 is add
void modify(int x, int l, int r, int ql, int qr, int y, ll z){
	if(l == ql && r == qr){
		if(y == 1){
			mutiplyd(x, z);
		}else{
			plusd(x, l, r, z);
		}
		return;
	}
	int mid = (l + r)>>1;
	pushdown(x, l, r, mid);
	if(ql <= mid && mid < qr){
		modify(x<<1, l, mid, ql, mid, y, z);
		modify(x<<1|1, mid+1, r, mid+1, qr, y, z);
	}
	else if(qr <= mid){
		modify(x<<1, l, mid, ql, qr, y, z);
	}else{
		modify(x<<1|1, mid+1, r, ql, qr, y, z);
	}
	v[x] = (v[x<<1]+v[x<<1|1]) % MOD;
}
ll query(int x, int l, int r, int ql, int qr){
	if(l == ql && r == qr){
		return v[x];
	}
	int mid = (l + r)>>1;
	pushdown(x, l, r, mid);
	if(ql <= mid && qr>mid){
		return (query(x<<1, l, mid, ql, mid) + 
				query(x<<1|1, mid + 1, r, mid + 1, qr))%MOD;
	}
	else if(qr <= mid){
		return query(x<<1, l, mid, ql, qr);
	}
	else{
		return query(x<<1|1, mid + 1, r, ql, qr);
	}
}
int main(){
	cin >> n >> m >> MOD;
	for(int i = 1; i <= n; i++){
		cin >> a[i];
	}
	build(1, 1, n);
	int l, r, k;
	while(m-- > 0){
		int oo;
		cin >> oo;
		if(oo == 1){
			cin >> l >> r >> k;
			modify(1, 1, n, l, r, 1, k);
		}else if(oo == 2){
			cin >> l >> r >> k;
			modify(1, 1, n, l, r, 2, k);
		}else{
			cin >> l >> r;
			cout << query(1, 1, n, l, r) << endl;
		}
	}
	return 0;
}

树状数组

不用理解原理, 背了就行.

单点修改, 区间求和

int v[100000];
int lowbit(int x){return x&-x;}
int query(int x){
    int sum = 0;
    for(int i = x; i; i-= lowbit(i)){
        sum+=v[i];
    }
    return sum; 
}
void modify(int x, int z){
    for(int i = x; i <= n; i+= lowbit(i)){
        v[i] += y;
    }
}

权值线段树求逆序对

什么是权值线段树呢?

就是考虑新开一些数组, 然后透过线段树对他们进行维护.

对于逆序对, 我们只需要对所有元素排个序, 然后, 我们把比 a[i] 小两倍的数的下标放进线段树, 那么一会统计的时候, 我们只需要找i + 1 到 n - 1这个范围的和就行了.

[6, 4, 3, 1]

[1, 3, 4, 6]

我们知道只有比i要小的数字在后面才有能有逆序对的可能. 

 所以1 不可能有逆序对产生, 而3可以有逆序对, 因为他前面有一个1比他小, 然后我们把1的下表放进线段树, 就是3, 然后我们找3的下表 + 1, 到n - 1的区间和, 你会算到1, 因为我们只把1放进去, 原理就是这样了.

    vector<long long> v;
    
    //segment tree update
    void update(int l, int r, int y, int x) {
        if (y < l || y > r) return;
        if (l == r) {
            v[x] = 1;
            return;
        }
        
        int mid = l + (r - l) / 2;
        if (y <= mid) update(l, mid, y, 2 * x + 1);
        else update(mid + 1, r, y, 2 * x + 2);
        
        v[x] = v[2 * x + 1] + v[2 * x + 2];
    } 
    
    //segment tree range sum query
    long long query(int l, int r, int ql, int qr, int x) {
        if (qr < l || ql > r) {
            return 0;
        }
        if (l >= ql && r <= qr) {
            return v[x];
        }
        
        int mid = l + (r - l) / 2;
        long long xx  = query(l, mid, ql, qr, 2 * x + 1);
        long long yy = query(mid + 1, r, ql, qr, 2 * x + 2);
        return xx + yy;
    }
    
    int reversePairs(vector<int>& nums) {
        int n = nums.size();
        
        v.resize(4 * n, 0);
        
        vector<pair<long long, long long> > vp(n);
        
        for (int i = 0; i < n; i++) {
            vp[i] = {nums[i], i}; 
        }
        
        sort(vp.begin(), vp.end());

        long long j = 0, ans = 0;
        for (int i = 0; i < n; i++) {
            while (j < n && 2 * vp[j].first < vp[i].first) {
                update(0, n - 1, vp[j].second, 0);
                j++;
            }
            ans += query(0, n - 1, vp[i].second + 1, n - 1, 0);
            
        }
        
        return ans;
    }

P2073

要同时维护最小值, 最大值, 还要支持删除操作. 

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
using namespace std;
const int oo=1e9 + 7;
const int n = 1000000;
int a[1100000];
int mi[4100000], ma[4100000];
void pushup(int x){
    mi[x] = min(mi[x<<1], mi[x<<1|1]);
    ma[x] = max(ma[x<<1], ma[x<<1|1]);
}
void build(int x, int l, int r){
    if(l == r){
        mi[x] = oo;
        ma[x] = 0;
        return;
    }
    int mid = (l + r)>>1;
    build(x<<1, l, mid);
    build(x<<1|1, mid+1, r);
    pushup(x);
}
void add(int x, int l, int r, int y){
    if(l == r){
        mi[x] = l;
        ma[x] = l;
        return;
    }
    int mid = (l + r)>>1;
    if(y <= mid)add(x<<1, l, mid, y);
    else add(x<<1|1, mid+1, r, y);
    pushup(x);
}
void remove(int x, int l, int r, int y){
    if(l == r){
        mi[x] = oo;
        ma[x] = 0;
        return;
    }
    int mid = (l + r)>>1;
    if(y <= mid) remove(x<<1, l, mid, y);
    else remove(x<<1|1, mid+1, r, y);
    pushup(x);
}
int main(){
    build(1, 1, n);
    int k, l, r;
    long long sum1 =0, sum2=0;
    while(1){
        cin >> k;
        cout << k;
        if(k == 1){
            cin >> l >> r;
            if(a[r] == 0){
                a[r] = l;
                sum1+=l;
                sum2+=r;
                add(1, 1, n, r);
            }
        }else if(k == 3){
            if(mi[1] == oo)continue;
            sum1 -= a[mi[1]];
            sum2 -= mi[1];
            a[mi[1]] = 0; 
            remove(1, 1, n, mi[1]);
        }else if (k == 2){
            if(ma[1] == 0)continue;
            sum1-=a[ma[1]];
            sum2-=ma[1];
            a[ma[1]] = 0;
            remove(1, 1, n, ma[1]);
        }else{
            cout << sum1 << " " << sum2 << endl;
            return 0;
        }
    }
}

ZustinLau
关注
专栏目录
基于C++的线段树和树状数组（免费提供全部源码）
06-06
本项目旨在利用C++语言实现线段树和树状数组，以解决在计算机科学和工程中的区间查询和修改问题。线段树和树状数组是处理静态和动态区间操作的高效数据结构，广泛应用于数据分析、图像处理和游戏开发等领域。 模块...
二叉排序树BST实现笔记
qq_26239785的博客
08-13 344
题目链接 acwing3786 代码 #include<iostream> using namespace std; const int INF=0x3f3f3f3f; struct treenode { int val; treenode *left,*right; treenode(int _val) :val(_val),left(NULL),right(NULL){} }; treenode *root; void insert(treenode *&r
【算法修炼】二叉树算法一
Mxeron的博客
02-24 1039
二叉树算法一一、二叉树的遍历前序遍历中序遍历后序遍历遍历 or 位置？二叉树的最大深度（简单）二叉树的前序遍历（简单）二叉树的中序遍历（简单）二叉树的后序遍历（简单）前、中、后序位置的深究翻转二叉树（简单） 又开启了新的一章！数据结构中二叉树的相关算法的学习！ 同样学习自大佬：https://labuladong.gitee.io/algo/2/18/ 大佬一直强调先刷二叉树，但是自己相见恨晚，回溯、递归学完了才来刷二叉树，先刷二叉树可以对这之后的很多算法有更好的理解。 一、二叉树的遍历 树的问题就永远逃不
二叉树刷题总结
bigorange1的博客
07-30 482
二叉树相关题目：遍历、递归
超全C语言二叉树基本操作及讲解
疾风剑豪
04-20 1139
今天刷LeetCode上的题的时候，做到了关于二叉树的题，于是决定把这一块的知识整理一下。 1、二叉树的定义 二叉树通常以结构体的形式定义，如下，结构体内容包括三部分：本节点所存储的值、左孩子节点的指针、右孩子节点的指针。这里需要注意，子节点必须使用指针，就像我们定义结构体链表一样，下一个节点必须使用地址的方式存在在结构体当中。 struct TreeNode { int va...
二叉树的基本操作
marcushbs的博客
02-12 313
数据结构的一些知识很久没碰了，忘得差不多了都，来回顾总结一下，本篇先写一下二叉树相关的一些操作。 二叉树定义 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 二叉树的创建 通过输入先序二叉树序列创建二叉树，用'#'字符代表空节点。 //通过先序输入创建二叉树 TreeNode* CreateTreeByIn...
C++代码实例 - 线段树+树状数组.zip
最新发布
06-08
与线段树不同，树状数组基于数组而非树形结构，它利用前缀和的性质，通过位操作快速计算区间和。每个数组元素存储了以该位置为右端点的所有前缀和的增量。插入和查询操作同样能在O(log n)的时间内完成。相比于线段树...
线段树树状数组课件（ppt）
02-16
线段树&树状数组课件 树状数组&线段树是最基本的高级数据结构之二 一般出现于较难题中 应用广泛，可用于直接写正解/把暴力改进成正解/拿大量部分分
线段树和树状数组入门介绍
08-11
线段树和树状数组是两种在ACM（算法竞赛）和编程中广泛使用的高效数据结构，它们主要用于处理数组上的区间查询和修改操作。这里我们将深入理解这两种数据结构的原理和应用。 首先，线段树是一种能够支持动态维护...
线段树和树状数组——北京大学暑期课《ACM/ICPC竞赛训练》
05-14
线段树和树状数组是解决区间查询和更新问题的两种非常有效的数据结构。线段树提供了一种直观的方式来理解和处理区间操作，而树状数组则以其简洁性和高效性著称。这两种数据结构在算法竞赛以及实际编程中都具有广泛的...
C++二叉树基础 12.30
sdwsyns的博客
05-26 345
二叉树结构： struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 二叉树的遍历方式: 前序序列：根左右 (递归中常用到) 中序序列：左根右 后序序列：左右根 算法相关： （ps:原设定，一棵树只有一个节点或没有节点，它的深度都为0，而这里对于空节点的深度设定为-1，只有一个节点深度设为0） 1.计算二叉树深度 int height
如何创建一个简单的二叉树（TreeNode）？
weixin_39309402的博客
10-17 9798
我们都知道，数据结构最典型的就是数组和链表，在《算法图解》一书中，详细介绍了数组和链表的优缺点： 数组查询快（下标），但删除或者插入就比较慢（遍历） 链表与之相反，删除和插入元素很快，但查找很慢 所以二叉树就应运而生了，它结合二者的优点，取二家之长，但是在实际编程中，大多时候，根本用不到二叉树（实际编程中，我从来没用过二叉树，但是面试可能会问啊，所以趁有空学习总结下），网上找了一下二叉树的应用场...
前中后序的迭代和递归写法
sdsc1314的博客
09-16 430
前序 递归 class Solution { vector<int> res; public: vector<int> inorderTraversal(TreeNode* root) { if(root ==NULL ) { return res; } res.push_back(root->val); inorderTraversal(root-&gt
二叉树中序遍历：给定一个二叉树的根节点 root ，返回 它的 中序遍历。
m0_52485041的博客
10-22 903
二叉树中序遍历，力扣热题100
TreeNode
qq_38494269的博客
07-24 2197
可以使用前序遍历，这样才先优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。回溯法，一定要注意这种通过记录深度来找节点的题目。可以通过层序遍历的方式，获得每层最右边节点，效率更高的是通过后序遍历，保证同层先访问最右边节点。pair存储搜索二叉树的最小值和最大值，-1代表不是二叉搜索树（当树的参数值有-1就不行了）要注意为什么求高度的时候要做是否是平衡二叉树的判断，中序遍历下，输出的二叉搜索树节点的数值是有序序列。//注意不同递归方式,返回值不同。要找深度最大的叶子节点。...
C++ 小白入门leetcode (三）——tree 树 简单题目 详细解析
www_z_dd的博客
03-14 890
Tree C++ 100. 相同的树 给定两个二叉树，编写一个函数来检验它们是否相同。 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 一： class Solution { public: static string s; bool isSameTree(TreeNode* p, TreeNode* q) { if(p==NULL&a...
JDK8：HashMap源码解析：TreeNode类的moveRootToFront方法
老艮头的后知后觉
06-03 2869
一、概述 TreeNode在增加或删除节点后，都需要对整个树重新进行平衡，平衡之后的根节点也许就会发生变化，此时为了保证：如果HashMap元素数组根据下标取得的元素是一个TreeNode类型，那么这个TreeNode节点一定要是这颗树的根节点，同时也要是整个链表的首节点。 二、方法解析 /** * 把红黑树的根节点设为 其所在的数组槽 的第一个元素 * 首先明确：TreeNode既...
线段树与树状数组解最大子段和问题
"最大子段和-线段树树状数组课件（ppt）" 本文主要探讨了在信息竞赛和算法领域中常见的两种数据结构——线段树和树状数组，以及它们在处理最大子段和问题上的应用。首先，最大子段和问题指的是在一个序列中寻找具有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值