C++蓝桥杯实训篇（三）

news2025/4/17 21:48:05
片头

嗨！小伙伴们，大家好~ 今天我们来学习前缀和与差分相关知识，准备好了吗？咱们开始咯！

一、一维前缀和

以上，是我们用数学知识求解区间和，现在我们使用前缀和来求解：

 我们知道，求[L，R]的区间和 =>

当L>0时，结果为：sum[R] - sum[L-1] 

当L=0时，结果为：sum[R]

我们可以用代码来实现：

#include<iostream>
using namespace std;

const int n = 6;
int sum[n];

//求前缀和
int get_sum(int L, int R) 
{
	if (L == 0) return sum[R];
	else return sum[R] - sum[L - 1];
}

int main() {
	int arr[n] = { 1,3,7,5,2 };

	//填充sum数组

	sum[0] = arr[0];//sum数组的第1个元素和arr数组中的第1个元素的值相同
	for (int i = 1; i < n; i++) 
	{
		sum[i] = sum[i - 1] + arr[i];
	}

	cout << "[2,4] = " << get_sum(2, 4) << endl;
	cout << "[0,3] = " << get_sum(0, 3) << endl;
	cout << "[3,4] = " << get_sum(3, 4) << endl;

	return 0;
}

 

 二、一维差分

以上是利用数学知识求解，如果我们使用差分数组的思想，怎么做呢？

由此，我们得出：求[L，R] + value 时，d[L] + value ，d[R+1] - value

简单证明一下：

我们还可以让差分数组d里面的元素全部初始化为0，这样更方便：

 

 代码实现如下：

#include<iostream>
using namespace std;

int d[6] = { 0 };		//差分数组
int sum_d[6] = { 0 };	//前缀和差分数组

//根据形参修改差分数组里面的元素
void add(int L, int R, int value) {
	d[L] += value;
	d[R + 1] -= value;

}


int main() {
	int arr[5] = { 1,3,7,5,2 };
	add(2, 4, 5);
	add(1, 3, 2);
	add(0, 2, -3);

	//求前缀和差分数组里面的值
	sum_d[0] = d[0];
	for (int i = 1; i < 5; i++) 
	{
		sum_d[i] = sum_d[i - 1] + d[i];
	}

	//求新的arr数组
	for (int i = 0; i < 5; i++) {
		arr[i] += sum_d[i];
		cout << arr[i] << " ";
	}

	//清除差分数组里面的数据
	memset(d, 0, sizeof(d));
	cout << endl;

	return 0;
}

第1题  大学里的树木要维护

这道题，运用到了我们刚刚学的前缀和的思想。 

#include <iostream>
using namespace std;

const int N = 100086;
int a[N];
int sum[N];

//求[L,R]的区间和
int price(int L,int R){
  if(L == 1) return sum[R];
  else return sum[R] - sum[L-1];
}

int main()
{
  int n;     //总共有多少棵树
  cin >> n;

  int m;     //总共有多少个区间
  cin >> m;

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

  //前缀和
  sum[0] = a[0];
  for(int i = 1; i<=n; i++){
    sum[i] = sum[i-1] + a[i];
  }

  int L = 0,R = 0;
  while(m--)
  {
    cin >> L >> R;
    cout<<price(L,R)<<endl;
  }

  return 0;
}

我们还可以将代码优化：

#include <iostream>
using namespace std;

const int N = 100086;
int a[N];
int sum[N];

int main()
{
    int n,m;
    cin >> n >> m;

    for(int i = 1; i<= n; i++){
      cin >> a[i];
      sum[i] = sum[i-1] + a[i];   //可以一边输入a[i],一边计算sum[i]
    }

    int left = 0,right = 0;
    while(m--){
      cin >> left >> right;
      cout<<sum[right]-sum[left-1]<<endl; //如果left==1,left-1==0,sum[0] = 0
                                          //若left为1,结果仍然是sum[right]
    }

  return 0;
}
 三、二维前缀和

一维的前缀和求的只是一排序列的和值，宏观上看，是一条线段、一段区间。

但是二维的前缀和求的是一个矩形的和值，我们用图来表示，假设存在一个二维数组 a_{i,j}，从（1，1）到（4，4）。

我们需要求中间的小矩形的和值，那么应该如何快速求解呢？

3.2 二位前缀数组 

我们定义前缀和数组 sum_{i,j} 为从（1，1）~（i，j）的和值，例如下图：

 那么如何快速求解从（2，2）~（3，3）的和值呢？

我们利用一下容斥的思想，可以得到：

sum_{(2,2)~(3,3)} = sum_{3,3} - sum_{1,3} - sum_{3,1} + sum_{1,1}

我们用图表示：

 可以看到，我们尝试从灰色的部分剥离出多余的矩形，但是当减去了红色和绿色的部分后，发现黄色的部分被多减去了1次，因此需要加回来。

那么如何求维护二位前缀和呢？

我们用递推的思想，假设我们要求 sum_{n,m} ，我们以及知道了 sum_{n-1,m} ，那么我们可以用 \sum_{i=1}^{j}a_{n,j} + sum_{n-1,j} 求出 sum_{n,m} ，如图：

  打个比方吧：

第2题 二维前缀和

 

 对于这道题，我们采用二位前缀和来求解：

先定义n行m列的二维数组，接着我们可以一边填写值一边将行累加

const int N = 1e3 + 10;  // 定义矩阵最大尺寸为1000+10(缓冲)
typedef long long ll;    // 使用long long类型防止大数溢出

ll sum[N][N];  // 二维前缀和数组
ll a[N][N];    // 原始矩阵数据
int n, m, q;   // n行m列的矩阵，q次查询

	cin >> n >> m >> q;  // 输入矩阵行列数和查询次数

	for (int i = 1; i <= n; i++) {
		// 第一步: 计算每行的前缀和
		for (int j = 1; j <= m; j++) {
			cin >> a[i][j];
			sum[i][j] = sum[i][j - 1] + a[i][j];  // 行前缀和
		}
	}

计算完行前缀和后，因为是二维前缀和，我们还需要将上方的前缀和累加进来

	cin >> n >> m >> q;  // 输入矩阵行列数和查询次数

	for (int i = 1; i <= n; i++) {
		// 第一步: 计算每行的前缀和
		for (int j = 1; j <= m; j++) {
			cin >> a[i][j];
			sum[i][j] = sum[i][j - 1] + a[i][j];  // 行前缀和
		}

		// 第二步: 将上方的前缀和累加进来
		for (int j = 1; j <= m; j++) {
			sum[i][j] += sum[i - 1][j];  // 列前缀和累加
		}
	}

总的来说，前缀和计算分为两步：

① 先计算每行的前缀和（一维前缀和）

② 再将上方行的前缀和累加进来（转化为二维前缀和）

接着我们可以计算从（x1,y1) ~ (x2,y2) 之间的前缀和了

ll get_sum(int x1, int y1, int x2, int y2) {
	if (x1 > x2 || y1 > y2) return 0;	//越界处理
	return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
}

 这个函数使用前缀和数组快速计算子矩阵和，公式为：

sum = 右下角前缀和 - 上方前缀和 - 左侧前缀和 + 左上角前缀和

OK，我们再回到main函数中调用q次get_sum函数，最后将结果输出即可。

	while(q--) {
		int x1, y1, x2, y2;
		cin >> x1 >> y1 >> x2 >> y2;
		cout << get_sum(x1, y1, x2, y2) << endl;
	}

完整代码如下：

#include <iostream>
using namespace std;

const int N = 1e3 + 10;  // 定义矩阵最大尺寸为1000+10(缓冲)
typedef long long ll;    // 使用long long类型防止大数溢出

ll sum[N][N];  // 二维前缀和数组
ll a[N][N];    // 原始矩阵数据
int n, m, q;   // n行m列的矩阵，q次查询

ll get_sum(int x1, int y1, int x2, int y2) {
	if (x1 > x2 || y1 > y2) return 0;	//越界处理
	return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
}

int main() {
	//n行m列的矩阵
	//询问q次

	cin >> n >> m >> q;  // 输入矩阵行列数和查询次数

	for (int i = 1; i <= n; i++) {
		// 第一步: 计算每行的前缀和
		for (int j = 1; j <= m; j++) {
			cin >> a[i][j];
			sum[i][j] = sum[i][j - 1] + a[i][j];  // 行前缀和
		}

		// 第二步: 将上方的前缀和累加进来
		for (int j = 1; j <= m; j++) {
			sum[i][j] += sum[i - 1][j];  // 列前缀和累加
		}
	}


	while(q--) //调用q次
	{
		int x1, y1, x2, y2;
		cin >> x1 >> y1 >> x2 >> y2;
		cout << get_sum(x1, y1, x2, y2) << endl;
	}

	return 0;
}
 第3题  求和

其实这道题是一道数学问题，正好运用到了我们今天学的前缀和方法，一起来看看~

 okk，理解清楚题意后，咱们开始写代码啦~

#include <iostream>
using namespace std;

typedef long long ll;          // 定义ll为long long类型，防止大数溢出
const int N = 2e5 + 100;       // 定义数组最大大小，多100作为缓冲
ll a[N];    // 存储输入的原始数组
ll sum[N];  // 存储前缀和数组
int n;      // 存储元素个数

int main() {
	cin >> n;  // 输入元素个数n
	for (int i = 1; i <= n; i++) {
		cin >> a[i];                // 输入第i个元素
		sum[i] = sum[i - 1] + a[i]; // 计算前缀和：sum[i] = a[1] + a[2] + ... + a[i]
	}

	ll ret = 0;	 // 初始化结果为0
	for (int i = 1; i <= n; i++) {
		ret += sum[i - 1] * a[i];  // 累加前i-1个元素的和乘以当前元素
	}
	cout << ret << endl;  // 输出最终结果

	return 0;
}
 第4题 异或和之和

 代码如下：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int inf = 1e18;
const int N = 1e5+10;
/*
1.异或的自反性 a^b^b=a  al^...^ar = Sl-1 ^ Sr = (a1^a2^...^al-1) ^ (a1^a2^...^al-1) ^ (^al^...^ar)
2.比如异或运算的计算原理的方面。可以考虑把每个数按二进制拆分，在每一位上统计该位的贡献。2^i贡献
3.只有1有贡献，求区间异或和为1的子段数量 --->Sl^Sr=1  Sl=0 Sr=1 数量相乘O(n*V）
*/
void solve()
{
    int n;
    cin >> n;
    vector<int>a(n + 1);
    for (int i = 1; i <= n; i++)
        cin >> a[i];

    vector<int>s(n + 1);
    int num1, num0;
    int ans = 0;

    for (int i = 0; i <= 20; i++)//第i位
    {
        num1 = num0 = 0;
        num0 += 1;
        for (int j = 1; j <= n; j++)//第j个数
        {
            int num = (a[j] >> i) & 1;//第j个数的第i位是1还是0

            s[j] = s[j - 1] ^ num;//前缀异或和

            if (s[j] == 1)
            {
                num1++;
            }
            else
            {
                num0++;
            }//记录第i位0和1的数量

        }
        //cout << num1 << " " << num0 << endl;
        ans += num1 * num0 * (1 << i);//贡献为0和1的段之和和数值贡献的乘积
    }
    cout << ans << endl;

}
signed main()
{
    int t = 1;
//    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}
 第5题  挖矿

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int N=1e7+5;//评测用
int r[N]={0},l[N]={0};//两个数组存放正负方向的矿洞
int f=0,res=0;//
int main(){
int n,m;cin>>n>>m;
for(int i=1;i<=n;i++){
  int pos;cin>>pos;//输入坐标，即矿洞 
  if(pos>0) r[pos]++;//存放正负方向的矿洞
  if(pos<0) l[abs(pos)]++;
  if(!pos) f++;//也要考虑0坐标的矿洞
}
r[0]=l[0]=0;
for(int i=1;i<=m;i++){//移动距离最大为m，在m范围里前缀和，统计m范围里左右两边各自的矿洞
  r[i]+=r[i-1];
  l[i]+=l[i-1];
}
for(int i=1;i<=m;i++){//也是在m范围里考虑，计算矿石数目
   int sum1=r[i];
  if(m-2*i>0){
      sum1+=l[m-2*i];//从正坐标可以返回到负坐标的情况，如果返回不了直接等于第一个sum1
  }
    int sum2=l[i];
  if(m-2*i>0){
      sum2+=r[m-2*i];//从负坐标可以返回到正坐标的情况，如果返回不了直接等于第一个sum2
  }
  res=max({res,sum1,sum2});//正确更新res避免每次max被覆盖 
}
cout<<res+f;
return 0;
}
片尾

今天我们学习了前缀和和差分思想，希望看完这篇文章能对友友们有所帮助！！！

求点赞收藏加关注！！！

谢谢大家！！！

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

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

相关文章

【数据挖掘】岭回归（Ridge Regression）和线性回归（Linear Regression）对比实验

【数据挖掘】岭回归（Ridge Regression）和线性回归（Linear Regression）对比实验

这是一个非常实用的 岭回归&#xff08;Ridge Regression&#xff09;和线性回归&#xff08;Linear Regression&#xff09;对比实验&#xff0c;使用了 scikit-learn 中的 California Housing 数据集 来预测房价。 &#x1f4e6; 第一步&#xff1a;导入必要的库 import num…
阅读更多...
CExercise_07_1指针和数组_1编写函数交换数组中两个下标的元素

CExercise_07_1指针和数组_1编写函数交换数组中两个下标的元素

题目&#xff1a; 要求编写函数将数组作为参数传递来实现&#xff1a; 1.编写函数交换数组中两个下标的元素。函数声明如下&#xff1a;void swap(int *arr, int i, int j) 。要求不使用[]运算符&#xff0c;将[]还原成解引用运算符和指针加法来完成。 关键点 通过指针交换数组…
阅读更多...
塔能科技：智能路灯物联运维产业发展现状与趋势分析

塔能科技：智能路灯物联运维产业发展现状与趋势分析

随着智慧城市建设的推进&#xff0c;智能路灯物联运维产业正经历快速发展&#xff0c;市场规模持续扩大。文章探讨了智能路灯物联运维的技术体系、市场机遇和挑战&#xff0c;并预测了未来发展趋势&#xff0c;为行业发展提供参考。 关键词 智能路灯&#xff1b;物联运维&#…
阅读更多...
ZW3D二次开发_普通对话框_设置对话框弹出位置

ZW3D二次开发_普通对话框_设置对话框弹出位置

ZW3D的普通对话框可以在UI设计时静态地设置对话框弹出的位置&#xff0c;方法如下&#xff1a; 选中对话框的最顶级对象&#xff0c;即ZsCc::Form对象&#xff0c;在属性管理器中添加一个动态属性“form_pos”&#xff0c;类型为“StringList”&#xff0c;如下图所示 不同属性…
阅读更多...
低代码开发「JNPF」应用场景

低代码开发「JNPF」应用场景

政务系统快速搭建 在数字化政务转型的浪潮下&#xff0c;JNPF 快速开发平台扮演着关键角色&#xff0c;为政府部门提供了高效且便捷的审批流程自动化解决方案。 以 “一网通办” 为例&#xff0c;通过平台的可视化拖拽式配置功能&#xff0c;政府工作人员能够将原本复杂繁琐的…
阅读更多...
欧拉函数模板

欧拉函数模板

1.欧拉函数模板 - 蓝桥云课 问题描述 这是一道模板题。 首先给出欧拉函数的定义&#xff1a;即 Φ(n) 表示的是小于等于 n 的数中和 n 互质的数的个数。 比如说 Φ(6)2&#xff0c;当 n 是质数的时候&#xff0c;显然有 Φ(n)n−1。 题目大意&#xff1a; 给定 n 个正整数…
阅读更多...
屏幕空间反射SSR-笔记

屏幕空间反射SSR-笔记

屏幕空间反射SSR 相关文章&#xff1a; [OpenGL] 屏幕空间反射效果 Games202-RealTime GI in Screen Space github上的例子&#xff0c;使用visual studio2019 github例子对应的文章 使用OpenGL和C实现发光柱子的SSR倒影 下面是一个使用OpenGL和C实现屏幕空间反射(SSR)来创建…
阅读更多...
动态规划算法深度解析：0-1背包问题（含完整流程）

动态规划算法深度解析：0-1背包问题（含完整流程）

简介&#xff1a; 0-1背包问题是经典的组合优化问题&#xff1a;给定一组物品&#xff08;每个物品有重量和价值&#xff09;&#xff0c;在背包容量限制下选择物品装入背包&#xff0c;要求总价值最大化且每个物品不可重复选取。 动态规划核心思想 通过构建二维状态表dp[i]…
阅读更多...
LeetCode刷题SQL笔记

LeetCode刷题SQL笔记

系列博客目录 文章目录 系列博客目录1.distinct关键字 去除重复2.char_length()3.group by 与 count()连用4.date类型有个函数datediff()5.mod 函数6.join和left join的区别1. **JOIN&#xff08;内连接&#xff0c;INNER JOIN&#xff09;**示例&#xff1a; 2. **LEFT JOIN&a…
阅读更多...
循环神经网络 - 参数学习之随时间反向传播算法

循环神经网络 - 参数学习之随时间反向传播算法

本文中&#xff0c;我们以同步的序列到序列模式为例来介绍循环神经网络的参数学习。 循环神经网络中存在一个递归调用的函数 &#x1d453;(⋅)&#xff0c;因此其计算参数梯度的方式和前馈神经网络不太相同。在循环神经网络中主要有两种计算梯度的方式&#xff1a;随时间反向…
阅读更多...
球类（继承和多态）

球类（继承和多态）

父类Ball&#xff0c;设置为抽象类&#xff0c;调用get和set方法创建对象&#xff0c;将子类重写的功能函数抽象化。 // 抽象球类 abstract class Ball {private String name;private double radius; // 半径private double weight; // 重量private double price; // 价格// 构…
阅读更多...
DFS和BFS的模版

DFS和BFS的模版

dfs dfs金典例题理解就是走迷宫 P1605 迷宫 - 洛谷 dfs本质上在套一个模版&#xff1a; ///dfs #include<bits/stdc.h> using namespace std; int a[10][10]{0}; int m,n,t,ans0; int ex,ey; int v[10][10]{0}; int dx[4]{-1,0,1,0}; int dy[4]{0,1,0,-1}; void dfs(in…
阅读更多...
Ansible Playbook 进阶探秘：Handlers、变量、循环及条件判断全解析

Ansible Playbook 进阶探秘：Handlers、变量、循环及条件判断全解析

192.168.60.100ansible.com192.168.60.110 client-1.com 192.168.60.120client-2.com192.168.60.130client-1.com 一、Handlers 介绍&#xff1a;在发生改变时执行的操作(类似puppet通知机制) 示例&#xff1a; 当apache的配置文件发生改变时&#xff0c;apache服务才会重启…
阅读更多...
MATLAB的24脉波整流器Simulink仿真与故障诊断

MATLAB的24脉波整流器Simulink仿真与故障诊断

本博客来源于CSDN机器鱼&#xff0c;未同意任何人转载。 更多内容&#xff0c;欢迎点击本专栏目录&#xff0c;查看更多内容。 目录 0 引言 1 故障数据采集 2 故障特征提取 3 故障诊断分类 4 结语 本博客内容是在MATLAB2023下完成。 0 引言 对于电力电子电路的故障诊断…
阅读更多...
linux第三次作业

linux第三次作业

1、将你的虚拟机的网卡模式设置为nat模式&#xff0c;给虚拟机网卡配置三个主机位分别为100、200、168的ip地址 2、测试你的虚拟机是否能够ping通网关和dns&#xff0c;如果不能请修改网关和dns的地址 3、将如下内容写入/etc/hosts文件中&#xff08;如果有多个ip地址则写多行&…
阅读更多...
国标GB28181视频平台EasyCVR顺应智慧农业自动化趋势，打造大棚实时视频监控防线

国标GB28181视频平台EasyCVR顺应智慧农业自动化趋势，打造大棚实时视频监控防线

一、方案背景 近年来&#xff0c;温室大棚种植技术凭借其显著的优势&#xff0c;在提升农作物产量和质量、丰富农产品供应方面发挥了重要的作用&#xff0c;极大改善了人们的生活水平&#xff0c;得到了广泛的推广和应用。大棚内的温度、湿度、光照度和二氧化碳浓度等环境因素…
阅读更多...
HOOPS Visualize：跨平台、高性能的三维图形渲染技术解析

HOOPS Visualize：跨平台、高性能的三维图形渲染技术解析

在当今数字化时代&#xff0c;三维可视化技术已成为众多行业的核心竞争力。HOOPS Visualize作为一款功能强大的三维图形渲染引擎&#xff0c;凭借其卓越的渲染能力、跨平台支持、丰富的交互功能、高度定制化以及快速部署等特性&#xff0c;为开发人员提供了构建高质量、高性能3…
阅读更多...
蓝桥杯 C/C++ 组历届真题合集速刷（一）

蓝桥杯 C/C++ 组历届真题合集速刷（一）

一、1.单词分析 - 蓝桥云课 &#xff08;模拟、枚举&#xff09;算法代码&#xff1a; #include <bits/stdc.h> using namespace std;int main() {string s;cin>>s;unordered_map<char,int> mp;for(auto ch:s){mp[ch];}char result_charz;int max_count0;fo…
阅读更多...
多类型医疗自助终端智能化升级路径（代码版.上）

多类型医疗自助终端智能化升级路径（代码版.上）

大型医疗自助终端的智能化升级是医疗信息化发展的重要方向，其思维链一体化路径需要围绕技术架构、数据流协同、算法优化和用户体验展开： 一、技术架构层：分布式边缘计算与云端协同 以下针对技术架构层的分布式边缘计算与云端协同模块，提供具体编程实现方案： 一、边缘节点…
阅读更多...
区间 DP 详解

区间 DP 详解

文章目录 区间 DP分割型合并型环形合并 区间 DP 区间 DP&#xff0c;就是在对一段区间进行了若干次操作后的最小代价&#xff0c;一般是合并和拆分类型。 分割型 分割型&#xff0c;指把一个区间内的几项分开拆成一份一份的&#xff0c;再全部合起来就是当前答案&#xff0c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023