GDPU 竞赛技能实践 天码行空6 线段树 离散数组

已于 2024-06-03 14:39:19 修改
阅读量1.1k 收藏 9
点赞数 42
分类专栏： # 竞赛技能实践 文章标签： 算法
于 2024-04-03 19:15:38 首次发布
兑生：前世大厂架构师、上市公司CEO，被小人陷害，重生为25应届生，三连加关注，看我如何逆风翻盘。
本文链接：https://blog.csdn.net/lt6666678/article/details/137355429
版权

📖 敌兵布阵

C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。

中央情报局要研究敌人究竟演习什么战术,所以Tidy要随时向Derek汇报某一段连续的工兵营地一共有多少人,例如Derek问:“Tidy,马上汇报第3个营地到第10个营地共有多少人!”Tidy就要马上开始计算这一段的总人数并汇报。但敌兵营地的人数经常变动，而Derek每次询问的段都不一样，所以Tidy不得不每次都一个一个营地的去数，很快就精疲力尽了，Derek对Tidy的计算速度越来越不满:"你个死肥仔，算得这么慢，我炒你鱿鱼!”Tidy想：“你自己来算算看，这可真是一项累人的工作!我恨不得你炒我鱿鱼呢!”无奈之下，Tidy只好打电话向计算机专家Windbreaker求救,Windbreaker说：“死肥仔，叫你平时做多点acm题和看多点算法书，现在尝到苦果了吧!”Tidy说："我知错了。。。"但Windbreaker已经挂掉电话了。Tidy很苦恼，这么算他真的会崩溃的，聪明的读者，你能写个程序帮他完成这项工作吗？不过如果你的程序效率不够高的话，Tidy还是会受到Derek的责骂的.

输入
第一行一个整数T，表示有T组数据。
每组数据第一行一个正整数N（N<=50000）,表示敌人有N个工兵营地，接下来有N个正整数,第 i 个正整数 a i a_i ai​ 代表第i个工兵营地里开始时有 a i a_i ai​ 个人（ 1 < = a i < = 50 1<=a_i<=50 1<=ai​<=50）。

接下来每行有一条命令，命令有4种形式：

  • Add i j，i和j为正整数,表示第 i 个营地增加 j 个人（j不超过30）
  • Sub i j，i和j为正整数,表示第 i 个营地减少 j 个人（j不超过30）;
  • Query i j，i和j为正整数，i<=j，表示询问第i到第 j 个营地的总人数;
  • End 表示结束，这条命令在每组数据最后出现;

每组数据最多有40000条命令

输出
对第i组数据,首先输出“Case i:”和回车,
对于每个Query询问，输出一个整数并回车,表示询问的段中的总人数,这个数保持在int以内。

⌨ 输入样例

1
10
1 2 3 4 5 6 7 8 9 10
Query 1 3
Add 3 6
Query 2 7
Sub 10 2
Add 6 3
Query 3 10
End

💻 输出样例

Case 1:
6
33
59

👨‍🏫 参考地址

💖 线段树版

⏰ 时间复杂度： O ( n l o g n ) O(nlogn) O(nlogn)，建树、查询、单点修改都是
在这里插入图片描述

🌟 Main.java

import java.util.Scanner;

class SegmentTree
{
	// 定义内部类 Node，表示线段树的节点
	class Node
	{
		int l, r, sum;// 区间为 [l,r],区间和为 sum

		// Node 类的构造函数，用于初始化节点的起始和结束位置以及和
		Node(int a, int b)
		{
			this.l = a;
			this.r = b;
			this.sum = 0;
		}
	}

//	数组存树，tree[i] 的左儿子为 tree[2i],右儿子为 tree[2i+1]
	Node[] tree; // 线段树数组，存储线段树的节点
	int[] workers; // 工兵营地人数数组，存储每个工兵营地的人数

	// SegmentTree 类的构造函数，初始化线段树和工兵营地人数数组
	SegmentTree(int n)
	{
		tree = new Node[4 * n]; // 线段树数组的大小是工兵营地数量的 4 倍
		workers = new int[n + 1]; // 工兵营地人数数组的大小是工兵营地数量加一
	}

	// 构造线段树的方法
	/**
	 * @param l   区间左边界
	 * @param r   区间右边界
	 * @param cur 当前区间的根节点
	 */
	void build(int l, int r, int cur)
	{
		tree[cur] = new Node(l, r); // 初始化线段树的节点
		// 如果起始位置和结束位置相同，表示到达叶子节点，将叶子节点的和设置为对应工兵营地的人数
		if (l == r)
			tree[cur].sum = workers[l];
		else
		{
			// 如果不是叶子节点，则递归构造左右子树，并将当前节点的和设置为左右子树和的和
			int mid = (l + r) / 2;
			build(l, mid, cur * 2);
			build(mid + 1, r, cur * 2 + 1);
			tree[cur].sum = tree[cur * 2].sum + tree[cur * 2 + 1].sum;
		}
	}

	// 查询线段树中指定闭区间 [l,r] 的和
	/**
	 * @param l   区间左边界
	 * @param r   区间右边界
	 * @param cur 当前区间的根节点
	 */
	int query(int l, int r, int cur)
	{
		int sum = 0;
		// 如果查询范围包含了当前节点的范围，则返回当前节点的和
		if (l <= tree[cur].l && r >= tree[cur].r)
			sum += tree[cur].sum;
		else
		{
			int mid = (tree[cur].l + tree[cur].r) / 2;
			// 否则根据查询范围的位置递归查询左右子树
			if (l > mid)// 查询的区间 和 左区间 没有交集
				sum += query(l, r, cur * 2 + 1);
			else if (r <= mid)// 查询的区间 和 右区间 没有交集
				sum += query(l, r, cur * 2);
			else// 和左右区间都有交集
			{
				sum += query(l, r, cur * 2);
				sum += query(l, r, cur * 2 + 1);
			}
		}
		return sum;
	}

	// 在线段树中指定位置增加值
	/**
	 * 单点修改：给 tree[idx].sum 加上 val 值
	 * 
	 * @param idx 要修改的值下标
	 * @param val 增加多少
	 * @param cur 当前节点
	 */
	void add(int idx, int val, int cur)
	{
		tree[cur].sum += val;// 子结点变动，父结点肯定得变动
		// 如果当前节点的范围等于要增加值的位置，则直接返回
		if (tree[cur].l == idx && tree[cur].r == idx)
			return;
		// 否则根据要增加值的位置递归更新左右子树
		if (idx > (tree[cur].l + tree[cur].r) / 2)
			add(idx, val, cur * 2 + 1);
		else
			add(idx, val, cur * 2);
	}
}

public class Main
{
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		int cnt = 0;
		int t = sc.nextInt(); // 读取测试用例数量
		while (t-- > 0)
		{
			int n = sc.nextInt(); // 读取工兵营地数量
			SegmentTree segmentTree = new SegmentTree(n); // 创建线段树实例
			segmentTree.workers[0] = 0;
			for (int i = 1; i <= n; i++)
				segmentTree.workers[i] = sc.nextInt(); // 读取每个工兵营地的人数
			segmentTree.build(1, n, 1); // 构造线段树
			System.out.println("Case " + ++cnt + ":");
			while (true)
			{
				String ch = sc.next(); // 读取操作类型
				if (ch.equals("End"))
					break;
				else if (ch.equals("Query"))
				{
					int l = sc.nextInt(); // 读取查询范围起始位置
					int r = sc.nextInt(); // 读取查询范围结束位置
					int sum = segmentTree.query(l, r, 1); // 查询线段树中指定范围的和
					System.out.println(sum); // 输出查询结果
				} else if (ch.equals("Add"))
				{
					int idx = sc.nextInt(); // 读取要增加值的位置
					int x = sc.nextInt(); // 读取要增加的值
					segmentTree.add(idx, x, 1); // 在线段树中指定位置增加值
				} else if (ch.equals("Sub"))
				{
					int idx = sc.nextInt(); // 读取要减少值的位置
					int x = sc.nextInt(); // 读取要减少的值
					segmentTree.add(idx, -x, 1); // 在线段树中指定位置减少值
				}
			}
		}
	}
}

运行结果
在这里插入图片描述

🌟 Cpp

Cpp代码全文摘抄

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
struct
{
    int a,b,sum;
}t[140000];
int r[50010],summ,k;
void buildd(int x,int y,int num)//构造线段树
{

    t[num].a=x;
    t[num].b=y;
    if(x==y)
        t[num].sum=r[y];
    else
    {
        buildd(x,(x+y)/2,num*2);
        buildd((x+y)/2+1,y,num*2+1);
        t[num].sum=t[num*2].sum+t[num*2+1].sum;
    }
}
void query(int x, int y, int num)//查找
{
    if(x<=t[num].a&&y>=t[num].b)
        summ+=t[num].sum;
    else{
        int minn=(t[num].a+t[num].b)/2;
        if(x>minn) query(x,y,num*2+1);
        else if(y<=minn)
            query(x,y,num*2);
        else
        {
            query(x,y,num*2);
            query(x,y,num*2+1);
        }
    }
}
void add(int x, int y, int num)//添加
{
    t[num].sum+=y;
    if(t[num].a==x&&t[num].b==x) return ;
    if (x>(t[num].a+t[num].b)/2) add(x,y,num*2+1);
    else add(x,y,num*2);
}
void sub(int x,int y,int num)//减少
{
    t[num].sum-=y;
    if(t[num].a==x&&t[num].b==x) return ;
    if(x>(t[num].a+t[num].b)/2) sub(x,y,num*2+1);
    else sub(x,y,num*2);
}
int main()
{
    int t;
    int cnt=0;
    scanf("%d",&t);
    while(t--)
    {
        int n,m;
        char ch[10];
        scanf("%d",&k);
        r[0]=0;
        for(int i=1;i<=k;i++)
            scanf("%d",&r[i]);
        buildd(1,k,1);
        printf("Case %d:\n",++cnt);
        while(scanf("%s",&ch))
        {
            if(strcmp(ch,"End")==0)
                break;
            else if(strcmp(ch,"Query")==0)
            {
                scanf("%d%d",&n,&m);
                summ=0;
                query(n,m,1);
                printf("%d\n",summ);
            }
            else if(strcmp(ch,"Add")==0)
            {
                scanf("%d%d",&n,&m);
                add(n,m,1);
            }
            else if(strcmp(ch,"Sub")==0)
            {
                scanf("%d%d",&n,&m);
                sub(n,m,1);
            }
        }
    }
    return 0;
}

测试结果
在这里插入图片描述

💖 树状数组版

⏰ 时间复杂度： O ( n l o g n ) O(nlogn) O(nlogn)
在这里插入图片描述

🌟 Main.java

import java.util.Scanner;

public class Main
{
	static int[] numbers = new int[500050]; // 存储输入的数据
//	prefixSum[i] 表示numbers区间（i-lowbit(i),i] 区间的所有数的和
	static int[] prefixSum = new int[500050]; // 存储树状数组的前缀和

	// 计算二进制中最低位1的位置，树状数组的核心函数
	static int lowbit(int x)
	{
//		假设   x = 12
//		补码：   0000 1100  目测lowbit(12) = 100（二进制） = 4
//		取反：   1111 0011  所有位都取反
//		取反+1：1111 0100
//		lowbit(x) = x补码 & (x补码取反+1) = 0000 0100
//
//		假设  y = -12
//		原码：1000 1100 (假设只有 8 位)
//		反码：1111 0011
//		补码：1111 0100 巧了：y的补码==x的补码取反加一
//
//		结论：lowbit(x) = x & (-x)
		return x & (-x);
	}

	// 建立树状数组
	static void buildPrefixSum(int n)
	{
		// 后面的节点只会依赖于前边的节点，所以从前往后更新
		for (int i = 1; i <= n; i++)
		{ // 遍历数组，计算树状数组的前缀和
			for (int j = i; j >= i - lowbit(i) + 1; j--) // 累加区间 (i-lowbit(i),i] 的值
				prefixSum[i] += numbers[j];
		}
	}

	// 计算前n个元素的前缀和
	static int calculatePrefixSum(int n)
	{
		int sum = 0;
//		累计 n~1 所有值的和, 分区间累加即可
//		(n-lowbit(n),n]，[ 某,n-lowbit(n)] ……
//		可见区间的步长为 当前区间的长度 lowbit(i)
		for (int i = n; i > 0; i -= lowbit(i))
			sum += prefixSum[i];
		return sum;
	}

	// 更新树状数组
	static void updatePrefixSum(int index, int value, int n)
	{
		for (int i = index; i <= n; i += lowbit(i)) // 按照lowbit规则，更新前缀和数组
			prefixSum[i] += value;
	}

	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in); // 创建Scanner对象，用于读取输入
		int testCaseCount = sc.nextInt(); // 读取测试用例的数量
		int caseNumber = 1; // 记录当前测试用例的编号
		while (testCaseCount-- > 0)
		{ // 处理每个测试用例
			int length = sc.nextInt(); // 读取数组长度
			for (int i = 1; i <= length; i++)
			{ // 读取数组元素
				numbers[i] = sc.nextInt();
			}
			buildPrefixSum(length); // 建立树状数组
			System.out.println("Case " + caseNumber++ + ":"); // 打印测试用例编号
			while (sc.hasNext())
			{ // 处理每个操作
				String operation = sc.next(); // 读取操作类型
				if (operation.equals("End")) // 如果操作类型为End，退出循环
					break;
				int start, end;
				start = sc.nextInt(); // 读取操作参数
				end = sc.nextInt();
				if (operation.equals("Query")) // 如果操作类型为Query，打印查询结果
					System.out.println(calculatePrefixSum(end) - calculatePrefixSum(start - 1));
				else if (operation.equals("Add")) // 如果操作类型为Add，更新树状数组
					updatePrefixSum(start, end, length);
				else if (operation.equals("Sub")) // 如果操作类型为Sub，更新树状数组
					updatePrefixSum(start, -1 * end, length);
			}
		}
		sc.close(); // 关闭Scanner对象
	}
}

🌟 Cpp

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
int a[500050];
int summ[500050];
int low(int x)//lowbit 函数，树状数组的核心
{
    return x&(-x);
}
void build(int n)//建立树状数组
{
    for(int i=1;i<=n;i++)
    {
        for(int j=i;j>=i-low(i)+1;j--)
            summ[i]+=a[j];
    }
}
int s_sum(int n)//求n前的和
{
    int sum=0;
    for(int i=n;i>0;i-=low(i))
        sum+=summ[i];
    return sum;
}
void update(int x,int y,int n)//对树状数组进行修改
{
    for(int i=x;i<=n;i+=low(i))
        summ[i]+=y;
}
int main()
{
    int t,k,num=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&k);
        memset(a,0,sizeof(a));
        memset(summ,0,sizeof(summ));
        for(int i=1;i<=k;i++)
            scanf("%d",&a[i]);
        build(k);
        char x[10];
        int a,b;
        printf("Case %d:\n",num++);
        while(scanf("%s",x))
        {
            if(strcmp(x,"End")==0)
                break;
            scanf("%d%d",&a,&b);
            if(strcmp(x,"Query")==0)
                printf("%d\n",s_sum(b)-s_sum(a-1));
            else if(strcmp(x,"Add")==0)
                update(a,b,k);
            else if(strcmp(x,"Sub")==0)
                update(a,-1*b,k);
        }
    }
    return 0;
}

测试结果
在这里插入图片描述

兑生
关注
  • 42
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树 单点修改+区间修改和查询 例题+代码
菜鸡成长史
07-03 858
目录 【单点修改，区间查询 例题】 【hdu 1166 敌兵布阵】 【hdu 1754I Hate It 】 【区间修改，区间查询 例题】 【hdu 1698Just a Hook】 【单点修改，区间查询 例题】 1.单点修改、区间查询 - hdu 1166 敌兵布阵 2.单点修改、区间查询最值 - hdu 1754I Hate It 【hdu 1166 敌兵布阵】 ...
树状数组（入门附模板）
cyyyyds857的博客
06-21 1901
树状数组或二叉索引树（英语：Binary Indexed Tree），又以其发明者命名为Fenwick树，最早由Peter M. Fenwick于1994年以A New Data Structure for Cumulative Frequency Tables为题发表在SOFTWARE PRACTICE AND EXPERIENCE。其初衷是解决数据压缩里的累积频率（Cumulative Frequency）的计算问题，现多用于高效计算数列的前缀和， 区间和。——源自百度百科。
HDU 1166 敌兵布阵（线段树基础)
Remilia's
01-24 1059
Problem Description C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视
树状数组的模板题
weixin_45652283的博客
06-15 341
思路：这道题的思想很简单，二维区间修改，我们首先想到的就是二维差分，然后在使用树状数组进行单点查询即可。思路：看到这样的问题，我们都会头大（没思路，烦死了！我们可以基于第二题的。思路：这同样也是一道模板题，对于区间修改，我们首先会想到的是。操作输出一行，每行有一个整数，表示所求的结果。操作输出一行，每行有一个整数，表示所求的结果。操作输出一行，每行有一个整数，表示所求的结果。操作，输出一个整数，表示对于这个操作的回答。操作，输出一个整数，表示对于这个操作的回答。操作，输出一个整数，表示对于这个操作的回答。
树状数组 模板题整理
雪岩的博客
10-26 405
树状数组整理： 1）单点修改，区间查询 例题：LibreOJ - 130 ac code： #include<bits/stdc++.h> using namespace std; const int maxn=1e6+1; typedef long long ll; ll p[maxn]; int a[maxn]; int n,m; int lowbit(int x){ return x&(-x); } void update(int x,ll add){//单点修改 for
GDPU信管ERP复习重点.docx
05-26
GDPU信管ERP复习重点
GDPU C语言程序设计 参考代码.zip
最新发布
06-13
【标题】"GDPU C语言程序设计 参考代码.zip" 涵盖了C语言编程的基本概念和实践技巧，适合初学者以及有一定基础的学习者参考。C语言是一种广泛使用的编程语言，它以其高效、灵活和强大的系统级编程能力而闻名。在本...
GDPU计算机组成原理试验1.2
09-05
GDPU计算机组成原理试验1.2
GDPU计算机组成原理试验1
09-05
GDPU计算机组成原理试验1
树状数组详解（附图解，模板及经典例题分析）
qq_63786973的博客
10-19 3329
顾名思义，就是像树一样的数据结构，与 Trie 树类似，其结构类型为完全二叉树，节点排列非常的有规律，故我们直接可以使用数组来模拟，以达到简洁而高效的目的
洛谷 P3374：树状数组模板题
hnjzsyjyj的专栏
10-01 346
【问题描述】 题目来源：https://www.luogu.com.cn/problem/P3374 如题，已知一个数列，你需要进行下面两种操作： • 将某一个数加上 x； • 求出某区间每一个数的和。【输入格式】 第一行包含两个正整数 n，m，分别表示该数列数字的个数和操作的总个数。 第二行包含 n 个用空格分隔的整数，其中第 i 个数字表示数列第 i 项的初始值。 接下来 m 行每行包含 3 个整数，表示一个操作，具体如下： • 1 x k 含义：将第 x 个数加上 k； • 2 x y 含义：输出区间
树状数组模板题：楼兰图腾
qq_49120553的博客
07-21 227
题目链接：https://www.acwing.com/problem/content/description/243/ 题目： 在完成了分配任务之后，西部314来到了楼兰古城的西部。 相传很久以前这片土地上(比楼兰古城还早)生活着两个部落，一个部落崇拜尖刀(V)，一个部落崇拜铁锹(∧)，他们分别用V和∧的形状来代表各自部落的图腾。 西部314在楼兰古城的下面发现了一幅巨大的壁画，壁画上被标记出了n个点，经测量发现这n个点的水平位置和竖直位置是两两不同的。 西部314 ...
树状数组模板题—hdu1166+poj2352
Delacour_的专栏
06-22 1312
题目链接 http://acm.hdu.edu.cn/showproblem.php?pid=1166
线段树(扫描线法，单点修改区间查询
supreme567的博客
06-15 138
#include <cstdio> #include <cstring> #include <iostream> #include <algorithm> using namespace std; const int N = 200010; int m, p; struct Node { int l, r; int v; // 区间[l, r]中的最大值 }tr[N * 4]; void pushup(int u) // 由子节点.
线段树（单点修改，区间查询）
nreyong的博客
09-16 332
题目链接：单点修改，区间查询 build：基于后序遍历和区间二分的思想，递归建树 change：1、r<x||l>x，当前区间与要修改的点无交集，直接return掉 2、l==r&&l==x，这个点为要修改的点，把对应位置修改后return 3、其他情况，递归找要修改的点，同时维护修改后的树 query：1、r<s||l>t，当前区间与查询区间无交集，返回0 2、s<=l&&r<=...
树状数组练习题
weixin_51552756的博客
08-08 344
一、 敌兵布阵（模板裸题） 1.题目描述 C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。 中央情报局要研究敌人究竟演习什么战术,所以Tidy要随时向Derek汇报某一段连续的工兵营地一共有多少人,例如D
codeforces 1023 D Array Restoration （树状数组）
qq_44791484的博客
02-25 184
题面 题意 有一个长度为n的序列，你可以进行 q 次修改，第i次修改将区间 [l,r] 的数修改成 i ，涉及的 q次修改必须要覆盖区间中的每个数，q 次修改之后，将这个序列中的某些数变为0，得到一个新的序列（就是输入的序列），问你能不能通过这个新的序列求出一个变0之前的合法序列 题解 要求的这个字符串肯定是要有q的，因为q是最后一次修改，修改之后肯定有q，那么就要求输入的这个序列要么包含q，要么包含0（我们就可以将0变为q），如果输入的序列既没有q也没0，那么一定输出NO 要想有合法序列
数据结构（荣誉）实验五 树状数组
上山打老虎的博客
06-15 309
目录1. 树状数组操作题目描述输入输出样例输入样例输出题解2. 逆序对题目描述输入输出样例输入样例输出题解3.矩阵操作题目描述输入输出样例输入样例输出提示题解 1. 树状数组操作 题目描述 给你n个数，创建一个树状数组，并执行相应操作，按格式要求输出操作结果。执行的操作有以下两种形式： C i dt ，表示更新A[i]，使得A[i]=A[i]+dt，其中1<=i<=n； Q i j ，表示询问区间和，即A[i]+A[i+1]+…+A[j]的值，其中1<=i<=j<=n。 输入
树状数组——【模板】树状数组1
虞念巧
10-13 746
树状数组模板题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值