Acwing 算法基础课 基础算法（二）高精度 前缀和 差分

于 2021-08-16 23:21:26 发布
阅读量140 收藏
点赞数
分类专栏： 算法学习 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Magic__KID/article/details/119687015
版权

Acwing 算法基础课基础算法【二】

高精度

A + B：两个大整数相加
A - B：两个大整数相减
A × a：一个大整数乘一个小整数
A ÷ a：一个大整数除以一个小整数

数的存储：
用一个数组来存大整数的每一位上的数，将大整数按从低位到高位存储，就是将个位存到数组的第一位，十位存到数组的第二位，依次类推，最高位存到数组的最后一位（目的是为了方便进位,这样子，数组对应元素相加，进位就进到数组的下一个元素）

高精度加法

思路：模拟人工加法
算法模板：

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

using namespace std;

vector<int> A,B;

vector<int> add(vector<int> &A, vector<int> &B)
{
    vector<int> res;                //定义一个存放结果
    int t = 0;                      //进位
    
    for (int i = 0; i<A.size() || i<B.size(); i ++ )//遍历A,B每一位数，当i都大于两个数的数位，才结束
    {
        if(i<A.size())  t += A[i];          //加上对应位的数字
        if(i<B.size())  t += B[i];
        res.push_back(t%10);                //加完后模10，剩余的做进位
        t /= 10;                            //进位
    }
    
    if(t)   res.push_back(t);               // for循环结束后，还有进位，说明溢出了一位
    
    return res;
    
}

int main()
{
    string a,b;             //读入数据  
    cin >> a >> b;          // a = "123456"  b = "123"
    
    for (int i = a.size()-1; i >= 0; i -- )    A.push_back(a[i]-'0');   //A = [6,5,4,3,2,1]
    for (int i = b.size()-1; i >= 0; i -- )    B.push_back(b[i]-'0');   //B = [3,2,1]
    
    vector<int> c = add(A,B);
    
    for (int i = c.size()-1; i >= 0; i -- )     printf("%d",c[i]);      //倒序输出
    
    return 0;
}

高精度减法

思路：模拟人工减法
算法模板：

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

using namespace std;
vector<int> A,B;
bool cmp(vector<int> &A,vector<int> &B)  //比较A是否大于等于B
{
    if(A.size()!=B.size())      return A.size() > B.size();		//两个数的位数不相同
    for (int i = A.size()-1; i >= 0; i -- )		// 位数相同
        if(A[i]!=B[i])      return A[i] > B[i];	// 比较每一位的数字
    return true;
}

vector<int> sub(vector<int> &A,vector<int> &B)		// A>=B 的减法
{
    vector<int> res;			
    int t = 0;				//借位
    for (int i = 0; i < A.size() || i < B.size(); i ++ )
    {
        t = A[i]-t;		//被减数上的每一位数先减去借位
        if(i < B.size())        t -= B[i];		//减去减数
        res.push_back((t+10)%10);		// t>0，差的对应数位就为t
        								// t<0, 差的对应数位应该为t+10
        if(t >= 0)     t = 0;			// t>0 说明够减 借位为0
        else           t = 1;			// t>0 说明不够减，需要借位 借位为1
    }
    
    return res;
}

int main()
{
    string a,b;
    cin >> a >> b;		//读入两个数
    
    for (int i = a.size()-1; i >= 0; i -- )       A.push_back(a[i]-'0');
    for (int i = b.size()-1; i >= 0; i -- )       B.push_back(b[i]-'0');
    
    if(cmp(A,B))		// A>=B时
    {
        auto C = sub(A,B);
        while (C.size() > 1 && C.back() == 0)     C.pop_back();
        for (int i = C.size()-1; i >= 0; i -- )       printf("%d",C[i]);
    }
    else				// A<B时   A-B=-(B-A)
    {
        auto C = sub(B,A);
        while (C.size() > 1 && C.back() == 0)     C.pop_back();
        printf("-");      	//先输出负号
        for (int i = C.size()-1; i >= 0; i -- )       printf("%d",C[i]);
    }
    
    return 0;
    
}

高精度乘法

思路：该算法A × b类似于人工乘法，不过要把b看成一位数的一个整体
举例：123 × 12，先计算3 × 12，得36，那么结果中的个位为：36 % 10 = 6，进位为36 / 10 = 3；再计算2 × 12，得24，需要加上进位3，得27，因此结果中的十位为：27 % 10 = 7，进位是27 / 10 = 2；再计算 1 × 12 ，得12 ，加上进位得14，结果上的百位为14 % 10 = 4，产生进位14 / 10 = 1，到A的最后数位后，如果有进位剩余，补上进位，最后输出结果1423

算法模板：(类似于加法模板)

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

using namespace std;
vector<int> A;
vector<int> multi(vector<int> &A, int b) 
{
    vector<int> res;
    int t = 0;		//进位
    for (int i = 0; i < A.size(); i ++ )
    {
        t = A[i]*b+t;		//乘上整体b并加上进位
        res.push_back(t%10);		// 填入对应位结果
        t /= 10;					// 进位
    }
    if(t)       res.push_back(t);	//多余的进位，补上
    
    return res;
}


int main()
{
    string a;
    int b;
    cin >> a >> b;
    
    for (int i = a.size()-1; i >= 0; i -- )       A.push_back(a[i]-'0');
    
    auto C = multi(A,b);
    while(C.size() > 1 && C.back()==0)      C.pop_back();
    for (int i = C.size()-1; i >= 0; i -- )       printf("%d",C[i]);
    
    return 0;
}

高精度除法

思路：模拟人工除法
模板：（模板中对存储结果的vector翻转后又逆序输出，是为了和前面的模板存储和输出保持统一）

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

using namespace std;

vector<int> div(vector<int> &A, int &b,int &r)
{
    vector<int> res;
    for (int i = A.size()-1; i >= 0; i -- )
    {
        r = r*10+A[i];              //  每一步除法就是余数r*10加上下一位数，再除以除数得到商的一位
        res.push_back(r/b);
        r %= b;                     //  对除数取模后得到新的余数r
    }
    reverse(res.begin(),res.end());
    while(res.size()>1 && res.back() == 0)      res.pop_back();
    
    return res;
}

vector<int> A;
int main()
{
    string a;
    int b;
    cin >> a >> b;
    
    for(int i=a.size()-1;i>=0;i--)        A.push_back(a[i]-'0');
    
    int r = 0;      // r用于存余数，初始化为0
    auto c = div(A,b,r);        
    
    for(int i=c.size()-1;i>=0;i--)        printf("%d",c[i]);
    
    cout << endl << r << endl;
    
    return 0;
}

前缀和

问题背景：
一个长度为n的数组。询问数组中从第l个数到第r个数的和。我们可以很容易想到用暴力for循环，但当有m次询问时，算法的复杂度为O(m*n)，当m,n超过一万就有可能超时，但采用前缀和算法，能将时间复杂度降到O(n+m)

一维前缀和原理

一个数组为[A1，A2，A3，A4，A5，…，An]（注意，下标从1开始）
那么前缀和数组为[S1，S2，S3，S4，S5，…，Sn],其中Si = A1+ A2 + … + Ai
Si-1 = A1+ A2 + … + Ai-1

Si = A1+ A2 + … + Ai-1 + Ai
因此，前缀和数组 Si = Si-1+ Ai

那么，对于求区间[l, r]中所有数的和，sum[L...R] = S[R] - S[L-1]
SL-1 = A1+ A2 + … + AL-1
SR = A1+ A2 + … + AL-1+ AL+ AL+1 + … + AR-1+AR
S~R~ - S~L-1~= ( A1+ A2 + … + AL-1+ AL+ AL+1 + … + AR-1+AR) - ( A1+ A2 + … + AL-1) = (A~L~+ A~L+1~ + … + A~R-1~+A~R~) = Sum[L...R]

一维前缀和模板

注意：数组从下标1开始存，并且将a[0]定义为0，S[0]定义为0,目的是为了好处理边界，例如要求数组第1个数到第10个数的和，那么根据前缀和将就可以写成s[10]-s[0]，如果数组从第下标0开始存，那么就变成了s[9]-s[-1]，有边界问题
Acwing 795 前缀和

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1e5+10;
int a[N],s[N],n,m;

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ )      scanf("%d", &a[i]);     // 从下标1开始读入数据
    for (int i = 1; i <= n; i ++ )      s[i] = s[i-1]+a[i];     // 从下标1开始初始化数组  
    
    while (m -- )
    {
        int l,r;
        scanf("%d%d", &l, &r);
        
        printf("%d\n",s[r]-s[l-1]);     //  sum(l...r) = s[r] - s[l-1]
    }
    
    return 0;
}

问题背景：
一个n行m列的整数矩阵，有q个询问，每个询问包含四个整数x1, y1, x2, y2，表示一个子矩阵的左上角坐标和右下角坐标。对于每个询问输出子矩阵中所有数的和。

二维前缀和原理

定义二维前缀和数组：
s[i][j]表示二维数组中，左上角(1,1)到右下角( i,j )所包围的矩阵元素的和。


紫色区域是指(1,1)左上角到(i,j-1)右下角的矩形面积, 绿色区域是指(1,1)左上角到(i-1, j )右下角的矩形面积。每一个颜色的矩形面积都代表了它所包围元素的和。

从图中我们很容易看出，整个外围蓝色矩形面积s[i][j] = 绿色面积s[i-1][j] + 紫色面积s[i][j-1] - 重复加的红色的面积s[i-1][j-1]+小方块的面积a[i][j];
因此得出二维前缀和处理公式
s[i][j] = s[i-1][j] + s[i][j-1] - s[i-1][j-1] + a[i][j]

ps：有点像概率论算二维随机变量的概率的例子

二维前缀和模板

注意：二维数组从行和列都下标1开始存，并且将a[0][0]定义为0，S[0][0]定义为0,目的一样是为了好处理边界。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;
int a[N][N],s[N][N];
int n,m,q;

int main()
{
    cin >> n >> m >> q;
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )   scanf("%d",&a[i][j]);
        
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )   s[i][j]=s[i][j-1]+s[i-1][j]-s[i-1][j-1]+a[i][j];     // 初始化二维前缀和数组
    
    while(q--)
    {
        int x1,y1,x2,y2;
        cin >> x1 >> y1 >> x2 >> y2;
        printf("%d\n",s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1]);		//二维数组前缀和计算公式：[i] [j] = s[i-1][j] + s[i][j-1] + a[i] [j] - s[i-1][ j-1]
    }
}

差分

差分是前缀和的逆运算

一维差分原理

一个数组A [A1，A2，A3，A4，A5，…，An],根据数组A 构造了数组B [B1，B2，B3，B4，B5，…，Bn],使得数组A是数组B的前缀和，即Ai等于数组B前i项和，那么数组B为数组A的差分

差分数组的作用: 在对长度为n的数组进行m次区间加减操作时，如果利用for循环，算法复杂度为O(n*m),利用差分数组时间复杂度为O(n+m)

例如：要对数组A中[l…r]区间内的全部元素都加上一个x
若数组B是A的差分数组，那么A数组的第i项都是数组B前i项的和，如果B[l]加上x，那么数组A下标l之后的Ai都会受影响，都会加上x，但只在[l…r]区间内加x，因此在B[r+1]上减去x，那么数组A下标r+1之后的Ai都会减去x，抵消了前面加x的影响，因此，对数组A的[l…r]区间内的所有数都加上一个x，只需要b[l]加x，b[r+1]减去x

一维差分模板

针对一个数组A [A1，A2，A3，A4，A5，…，An],构造他的差分数组B，可以借用上述区间加减的思想，数组B首先初始化为全零数组，之后在区间[1,1]插入A1,( 即 b[1]+A1，b[2]-A1)
在区间[2,2]插入A2(b[2]+A2，b[3]-A2)，…
在区间[n,n]插入An(b[n]+A1，b[n+1]-A1)
模板题：
Acwing 797 差分

#include <iostream>

using namespace std;

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

void insert(int l,int r,int val)
{
    b[l] += val;                  ///差分数组操作  b[l]+=c  b[r+1] -=
    b[r+1] -= val;
}

int main()
{
    cin >> 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,val;
        scanf("%d%d%d",&l,&r,&val);
        insert(l,r,val);
    }
    
    for (int i = 1; i <= n; i ++ )  b[i] += b[i-1];
    
    for (int i = 1; i <= n; i ++ )  printf("%d ",b[i]);
}

二维差分原理

在这里插入图片描述

有一个二维数组A，数组B是数组A的差分数组，那么Aij是数组B前i行前j列的和
(x1,y1) 和 (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。现在目的是要对 数组A中(x1,y1) 和 (x2,y2)构成子矩阵中（蓝色区域）所有元素都加上C
先对差分数组B中[x1][y1]位置上的元素加C，因为A是B的前缀和数组，那么读于数组A来说[x1][y1]这个点的右下角区域内的所有数都加上了C。但是影响了其他区域。不需要操作的区域需要抵消这部分影响；
将B[x2+1][y1]减掉C，那么对于数组A来说[x2+1][y1]这个点的右下角区域内的所有数都减去了C，再将B[x1][y2+1]减掉C，那么对于数组A来说[x2+1][y1]这个点的右下角区域内的所有数都减去了C，两次操作分别对应橙色区域。
但橙色区域重叠部分（红色区域）被减了2次C，所以红色区域要再加回一个C，即B[x2+1][y2+1]加上一个C。这样,一开始的加C 的影响全部抵消，数组A中(x1,y1) 和 (x2,y2)构成子矩阵中（蓝色区域）所有元素都加上C

//数组B是数组A的差分数组
//为了让数组A中(x1,y1) 和 (x2,y2)构成子矩阵中所有元素都加上C
	b[x1][y1] += c;
    b[x2+1][y1] -= c;
    b[x1][y2+1] -= c;
    b[x2+1][y2+1] += c

二维差分模板

差分数组的构造一般都借鉴对差分数组的修改操作
初始化一个全0的二维矩阵，为了构造数组A的差分数组B，相当于在[i,j]和[i,j]的大小为1 的子矩阵插入一个Aij，对应代码：

	b[i][j] += c;
	b[i+1][j] -= c;
	b[i][j+1] -= c;
	b[i+1][j+1] += c;

模板题：
Acwing 798 差分矩阵

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 1010;
int a[N][N],b[N][N];
int n,m,q;

void insert(int x1,int y1,int x2,int y2,int val)
{
    b[x1][y1] += val;
    b[x2+1][y1] -= val;
    b[x1][y2+1] -= val;
    b[x2+1][y2+1] += val;
}

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", &a[i][j]);
    
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )       insert(i,j,i,j,a[i][j]);
        
    while (q -- )
    {
        int x1,y1,x2,y2,val;;
        cin >> x1 >> y1 >> x2 >> y2 >> val;
        insert(x1,y1,x2,y2,val);
    }
    
    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]+b[i][j];
        
    for (int i = 1; i <= n; i ++ )
    {
        for (int j = 1; j <= m; j ++ )       
        {
            cout << b[i][j] << ' ';
        }
        cout << endl;
    }
    
    return 0;
}
Magic__KID
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值