acwing算法基础——高精度运算和前缀和差分

最新推荐文章于 2024-08-08 15:12:59 发布
最新推荐文章于 2024-08-08 15:12:59 发布
阅读量574 收藏 14
点赞数 14
分类专栏： 算法基础 文章标签： 算法 1024程序员节 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77668049/article/details/134226813
版权

作者：@黑眼圈ing
机电专业 工科男
CSDN@黑眼圈ing
每天进步一点点！

文章目录

备战蓝桥杯的第三天，今天学习的是常考的高精度算法和前缀和差分，我的学习方法：1.首先了解算法的主要思想，不能单单记住模板，2.多背模板，能够做到快速的写出模板，调debug，3.坚持每天做2、3道算法题，`

先赞后看,养成习惯! ! ! ^ _ ^ ❤️ ❤️ ❤️
*码字不易，大家的支持是我坚持的动力。点赞后不要忘了关注我哦!

一、高精度加法

高精度加法模板 //C = A + B
vector<int> add(vector<int>& A,vector<int>& B)
{		if(A.size()<B.size()) return add(B,A);
		vector<int> C;
		for(int i=0,t=0;i<=A.size();i++)//从低位到高位相加
		{	t+=A[i];
			if(i<B.size()) t+=B[i];
			C.push_back(t%10);
			t/=10;//进位
		}
		if(t) C.push_back(1);//处理最高位进位
}

高精度加法思想仿照我们小学的计算方法，从低位到高位依次相加，超过10就像前进一位，首先第一位t=0,C1=(A1+B1+t)%10的余数，进位t=(A1+B1+t)/10,第二位C2=（A2+B2+t）%10的余数,进位t=(A2+B2+t)/10,接下来重复找到规律
在这里插入图片描述

高精度加法完整版

#include <iostream>
#include <vector>
using namespace std;
// C =A + B
vector<int> add(vector<int>& A,vector<int>& B)
{		if(A.size()<B.size()) return add(B,A);
		vector<int> C;
		for(int i=0,t=0;i<=A.size();i++)//从低位到高位相加
		{	t+=A[i];
			if(i<B.size()) t+=B[i];
			C.push_back(t%10);
			t/=10;//进位
		}
		if(t) C.push_back(1);//处理最高位进位
		return C;
}

int main()
{	string a,b;//数值太大要用字符串存储
	vector<int> A,B;
	cin>>a>>b;//123456
	for(int i=a.size()-1;i>=0;i--)  A.push_back(a[i]-'0');//6 5 4 3 2 1
	for(int i=b.size()-1;i>=0;i--)  B.pusn_back(b[i]-'0');
	
	auto C=add(A,B);
	
	for(int i=C.size()-1;i>=0;i--) cout<<C[i];//从高位到低位输出
	
	return 0;
}

问题1：为什么有for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0')这步操作呢？
因为如果我们直接将字符串存入数组里，那么数组里a[0],a[1]等开始的位置存放的是高位，如果最高位要进1的话，就要将数据往后挪一位,时间复杂度就是O(n)。
将字符串逆序存入数组中，那么数组就是从低位到高位，最高位进位直接push_back

二、高精度减法

vector<int> sub(vector<int>& A,vector<int>& B)
{	vector<int> C;
	int t=0;
	for(int i=0;i<A.size();i++)
	{	t=A[i]-t;
		if(i<B.size()) t-=B[i];
		C.push_back(t%10);
		t/=10;
	}
	while(C.size()>1&&C.back()==0) C.pop_back();//处理前导0 "00034"的情况
	return C;
}

在这里插入图片描述

//高精度减法完整版
#include <iostream>
#include <vector>
using namespace std;
// C =A - B
vector<int> sub(vector<int>& A,vector<int>& B)
{
		vector<int> C;
		for(int i=0,t=0;i<=A.size();i++)//从低位到高位相加
		{	t=A[i]-t;
			if(i<B.size()) t-=B[i];
			C.push_back(t%10);
			t/=10;//进位
		}
		while(C.size()>1&&C.back()==0)  C.pop_back();//处理前导零
		return C;
}

int main()
{	string a,b;//数值太大要用字符串存储
	vector<int> A,B;
	cin>>a>>b;//123456
	for(int i=a.size()-1;i>=0;i--)  A.push_back(a[i]-'0');//6 5 4 3 2 1
	for(int i=b.size()-1;i>=0;i--)  B.pusn_back(b[i]-'0');
	
	auto C=sub(A,B);
	
	for(int i=C.size()-1;i>=0;i--) cout<<C[i];//从高位到低位输出
	
	return 0;
}

三、高精度乘法

//高精度乘法模板 高精度乘低精度
 // C = A * b
vector<int> mul(vector<int>& A,int b)
{	vector<int> C;
	int t=0;
	for(int i=0;i<A.size()||t;i++)
	{
		if(i<A.size()) t+=A[i]*b;
		C.push_back(t%10);
		t/=10;
	}
	while(C.size()>1&&C.back()==0) C.pop_back();
	return C:
}

在这里插入图片描述

//高精度乘法完整版
#include <iostream>
#include <vector>
using namespace std;
// C =A * b
vector<int> sub(vector<int>& A,int b)
{
		vector<int> C;
		int t=0;
		for(int i=0;i<=A.size()||t;i++)//从低位到高位相加
		{	
			if(i<B.size()) t+=A[i]*b;
			C.push_back(t%10);
			t/=10;//进位
		}
		while(C.size()>1&&C.back()==0)  C.pop_back();//处理前导零
		return C;
}

int main()
{	string a;//数值太大要用字符串存储
	int b;
	vector<int> A;
	cin>>a>>b;//123456
	for(int i=a.size()-1;i>=0;i--)  A.push_back(a[i]-'0');//6 5 4 3 2 1
	
	auto C=mul(A,b);
	
	for(int i=C.size()-1;i>=0;i--) cout<<C[i];//从高位到低位输出
	
	return 0;
}

四、高精度除法

//高精度除法模板
// C =A / b
vector<int> div(vector<int>& A,int b,int& r)
{		vector<int> C;
		r=0;
		for(int i=A.size()-1;i>=0;i--)
		{	r=10*r+A[i];
			C.push_back(r/b);
			r %= b;
		}
 		reverse(C.begin(),C.end());
 		while(C.size()>1&&C.back()==0) C.pop_back();
 		return C;
}

高精度除法需要注意的是除法从高位开始的，因为高精度加、减和乘都是从高位到低位输出的，所以高精度除法，我们要将C数组reverse !
在这里插入图片描述

//高精度除法完整版
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// C =A / b
vector<int> div(vector<int>& A,int b,int& r)
{
		vector<int> C;
		r=0;
		for(int i=A.size()-1;i>=0;i--)//从高位到低位
		{	
			r=10*r+A[i];
			C.push_back(r/b);
			r %= b;//进位
		}
		reverse(C.begin(),C.end());
		while(C.size()>1&&C.back()==0)  C.pop_back();//处理前导零
		return C;
}

int main()
{	string a;//数值太大要用字符串存储
	int b;
	vector<int> A;
	cin>>a>>b;//123456
	for(int i=a.size()-1;i>=0;i--)  A.push_back(a[i]-'0');//6 5 4 3 2 1
	
	int r;//余数
	auto C=div(A,b,r);
	
	for(int i=C.size()-1;i>=0;i--) cout<<C[i];//从高位到低位输出
	
	return 0;
}

五、前缀和

1.一维前缀和

一维前缀和多用来解决数组一部分区间的和，例如：有一个数组a[10],求从a[3]~a[6]区间的和，如果用暴力求解的话，时间复杂度是O(n),所以一般我们采用前缀和来求解
一维前缀和我们需要知道的是：1.前缀和数组b[i]=a[1]+a[2]+a[3]+...+a[i] 2.求部分和l~r a[l]+...a[r]=b[r]-b[l-1]
在这里插入图片描述

#include <iostream>
using namespace std;
const int N=1e6;
int q[N],a[N];
int n,m;

int main()
{   scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&q[i]);
    //前缀和数组
    for(int i=1;i<=n;i++) a[i]=a[i-1]+q[i];
    while(m--)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        printf("%d\n",a[r]-a[l-1]);
        
    }
    
    
    
    return 0;
}

2.二位前缀和

二位前缀和用来求矩阵的子矩阵子和
二位前缀和我们要知道:s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j]

在这里插入图片描述
在这里插入图片描述

#include <iostream>

using namespace std;

const int N = 1010;

int n, m, q;
int s[N][N];

int main()
{
    scanf("%d%d%d", &n, &m, &q);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            scanf("%d", &s[i][j]);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            s[i][j] += s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];

    while (q -- )
    {
        int x1, y1, x2, y2;
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        printf("%d\n", s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);
    }

    return 0;
}

六、差分

1.一维差分

一维差分：l~r区间加上c
一维差分我们要知道：差分数组q[l] += c,q[r+1] -= c

//构造差分数组
void insert(int l,int r,int c)
{	
	q[l] += c;
	q[r+1] -= c;
}
insert(l,r,c);

大家可能会有疑问为什么插入可以构造差分数组呢？
我们假设`原数组： a1, a2, a3, …, an
构造数组：b1, b2, b3, …, bn 使得 ai = b1 + b2 + b3 + … + bi（a数组就称为b数组的前缀和数组）
一种构造方式

  • b1 = a1, ----> a1 = b1
  • b2 = a2 - a1, ----> a2 = b1 + b2
  • b3 = a3 - a2, ----> a3 = b1 + b2 + b3
  • … …
  • … …
  • b(n) = a(n) - a(n-1) ----> an = b1 + b2 + b3 + … + bn
  • 原数组是a1, a2, a3, …, an, 可假设a数组初始时全是0, 立即推 ==> 差分数组b也全是0， 而给的a数组不是0，我们可以看作是进行了n次插入(insert)操作。
  • a1, insert(1,1,a[1])
  • a2, insert(2,2,a[2])
  • a3, insert(3,3,a[3])
  • …,
  • an, insert(n,n,a[n])
void insert(int l, int r, int c) {
    b[l] += c;
    b[r + 1] -= c;
}

for (int i = 1; i <= n; i++) insert(i, i, a[i]);

假设 a[] = {1, 3, 2, 1, 4}
我们把 a 数组带入代码中走一遍，看看结果(注意 b数组是全局变量，所以默认值全为0)
b1 = b1 + a1 = 0 + 1 = 1***
b2 = b2 - a1 = 0 - 1 = -1
b2 = b2 + a2 = -1 + 3 = 2***
b3 = b3 - a2 = 0 - 3 = -3
b3 = b3 + a3 = -3 + 2 = -1***
b4 = b4 - a3 = 0 - 2 = -2
b4 = b4 + a4 = -2 + 1 = -1***
b5 = b5 - a4 = 0 - 1 = -1
b5 = b5 + a5 = -1 + 4 = 3***
b6 = b6 - a5 = 0 - 4 = -4***
请注意带***的就是构造出来的b差分数组！！！可以将b数组求前缀和 它就是a 数**组了
`在这里插入图片描述

#include <iostream>

using namespace std;

const int N = 100010;
int n, m;
int a[N], b[N];

void insert(int l, int r, int c) {
    b[l] += c;
    b[r + 1] -= c;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);

    for (int i = 1; i <= n; i++) insert(i, i, a[i]);

    while (m--) {
        int l, r, c;
        scanf("%d%d%d", &l, &r, &c);
        insert(l, r, c);
    }  

    for (int i = 1; i <= n; i++) b[i] += b[i - 1];
    for (int i = 1; i <= n; i++) printf("%d ", b[i]);

    return 0;

}

2.二位差分

在这里插入图片描述
在这里插入图片描述

#include <iostream>
using namespace std;
const int N=1010;
int q[N][N],b[N][N];
int n,m,k;
void insert(int x1,int y1,int x2,int y2,int c)
{
    b[x2+1][y1]-=c;
    b[x1][y1]+=c;
    b[x1][y2+1]-=c;
    b[x2+1][y2+1]+=c;
    
}
int main()
{   scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;i<=m;i++)
        
            scanf("%d",&q[i][j]);
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;i<=m;i++)
         insert(i,j,i,j,q[i][j]);
    }
    
    while(k--)
    {   int x1,y1,x2,y2,c;
        cin>>x1>>x2>>y1>>y2>>c;
        insert(x1,y1,x2,y2,c);
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        b[i][j]+=b[i-1][j]+b[i][j-1]-b[i-1][j-1];
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            printf("%d",b[i][j]);
            
        }
        printf("\n");
    }
    
    return 0;
}

总结

欢迎各位大佬评论，如果有哪里有错误的地方，还请各位大佬指出，我会虚心接受的！！！

每天进步一点儿！！！
感谢大佬们的支持！！！感谢大佬们的支持！！！感谢大佬们的支持！！！

黑眼圈ing
关注
  • 14
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 13
    评论
专栏目录
算法竞赛入门基础篇（个人整理）
05-07
前缀和与差分** - 前缀和主要用于快速计算子区间的总和。 - 差分则用于通过差分数组恢复原数组，常用于更新操作频繁而查询较少的情况。 **5. 双指针算法** - 适用于数组中的两数之和、滑动窗口等问题。 **6. ...
leetcode中国-leetcode_algo:leetcode相关算法和模板使用python
06-29
前缀和与差分 双指针算法 回朔法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 栈与队列：单调队列、单调栈 kmp Trie 并查集 堆 Hash表 C++ STL使用...
【algorithm】算法基础课---高精度问题（附笔记 | 建议收藏）
congfen214的博客
11-30 1825
算法第三节---高精度学习。
【ACWing 算法基础】高精度减法
m0_51139226的博客
07-28 180
二. 例题 792. 高精度减法 给定两个正整数（不含前导 0），计算它们的差，计算结果可能为负数。 输入格式 共两行，每行包含一个整数。输出格式 共一行，包含所求的差。数据范围 1≤整数长度≤105 输入样例： 32 11 输出样例： 21AC代码：......
AcWing 792. 高精度减法(数组模拟，C++)
Alphacoo的博客
06-14 249
题意 给定两个正整数，计算它们的差，计算结果可能为负数。 正整数长度的范围是1到100000。 分析 1.先把两个数分别倒序存储在数组中，即最低位在最左边，最高位在最右边。 2.判断A和B哪个数更大，如果A大于B，则计算结果是正数；如果A等于B，则 计算结果是0,；如果A小于B，则计算结果是负数。 3.在进行减法运算时，是从最低位开始相减的；如果A在某个数位上的数比B小， 则A向前一个高位借一个1（即相当于当前数位的10）；最后再去掉A的前导零。 4.最后倒序输出。 代码 #include <iost
acwing.792.高精度减法
qq_47997583的博客
01-27 159
高精度减法 给定两个正整数，计算它们的差，计算结果可能为负数。 输入格式 共两行，每行包含一个整数。 输出格式 共一行，包含所求的差。 数据范围 1≤整数长度≤10510^5105 输入样例： 32 11 输出样例： 21 #include<iostream> #include<string> #include<vector> using namespace std; vector<int> A,B,C; bool Judge(vector<int&
Acwing高精度减法
weixin_44488944的博客
01-11 116
#include<algorithm> #include<iostream> #include<vector> #include<string> using namespace std; bool cmp(vector<int> &A,vector<int> &B)//判断A大还是B大 { if(A.s...
算法模板1
08-03
4. **前缀和与差分**：这些技巧用于快速计算序列中连续子区间之和，减少重复计算。 5. **离散化**：对数组元素进行排序和去重，使得处理连续数据时效率更高。 6. **区间和并**：处理区间查询和修改的问题，如树状...
leetcode中国-DataStructure:数据结构与算法的学习basepython/c++
06-29
:check_box_with_check:（一维、二维前缀和与差分） :check_box_with_check: 位运算 离散化 区间合并 数据结构 链表与邻接表：树与图的存储 :check_box_with_check: 栈与队列：单调队列、单调栈:check_box_with_...
leetcode中国-MyAlgorithmSolutions::balloon:记录我所有的算法/数据结构
06-29
前缀和差分 双指针 位运算 离散化 区间合并 单链表 双链表 栈 队列 单调栈 单调队列 KMP Tire 并查集 堆 哈希表 DFS BFS 快速幂 背包问题 区间DP 区间问题 绝对值不等式 DP课 寒假每日一题 基础班 提高班 POJ 大二 ...
AcWing 792 高精度减法
昂昂累世士的博客
08-07 293
题目描述： 给定两个正整数，计算它们的差，计算结果可能为负数。 输入格式 共两行，每行包含一个整数。 输出格式 共一行，包含所求的差。 数据范围 1≤整数长度≤105 输入样例： 32 11 输出样例： 21 分析： 高精度的减法与加法类似，都是用向量存储高精度的数，然后模拟减法计算过程。在高精度加法中，只需要第一个数位数不小于第二个数即可，而减法则有着严格的大小关...
AcWing高精度减法
独自莫凭欗的博客
08-01 153
题目链接：AcWing高精度减法 #include <iostream> #include <vector> using namespace std; const int N = 1000010; bool cmp(vector<int> &A, vector<int> &B) { if (A.size() != B.size()) return A.size() >= B.size(); for (int i = A
[AcWing]高精度加减乘除运算
duchenlong的博客
10-25 342
高精度加，减，乘，除运算高精度加法高精度减法
P1145 约瑟夫
zty20120913的博客
08-06 424
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 939
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 248
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 574
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
CSP - J day7
2301_81608637的博客
08-06 189
答案具有单调性：对于正确答案 ans ，小于 ans 的都一定符合条件，大于 ans 的一定不符合条件，因此可以二分答案。先dfs到叶节点，再逐步递归出来，过程中节点数增加，一旦达到 mid ，ans 加一，同时向上贡献节点数变为零。
ACWing基础算法入门：前缀和与二维差分矩阵讲解
本资源是一份关于ACWing基础算法课程的详细笔记，针对第一章的内容进行了整理。章节重点介绍了二维前缀和的概念，包括其在数据结构中的理解和记忆方法。二维前缀和用于高效计算从左上角到某一点的所有元素之和，通过...
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黑眼圈ing

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值