第一章 基础算法（二）——高精度，前缀和与差分

最新推荐文章于 2024-07-17 23:24:38 发布
最新推荐文章于 2024-07-17 23:24:38 发布
阅读量393 收藏
点赞数 1
分类专栏： AcWing算法基础课 课程记录 文章标签： 算法 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61432764/article/details/131314761
版权

文章目录

高精度运算

两个大数做运算，位数一般是1e6

大整数的存储，数组的低位存储整数的低位，类似于小端存储

高精度加法

Ai + Bi + t：每一位相加，再加上进位，一开始进位为0
用t变量保存Ai和Bi相加的结果，不过需要先判断这两个数是否存在，一开始t为0
当A和B的每一位数都加完后，还判断是否还有进位，即t是否为1，若有进位，最高位需要补上1

// C = A + B
vector<int> add(vector<int>& A, vector<int>& B)
{
	vector<int> C;
	int t = 0; // 进位
	for (int i = 0; i < A.size() || i < B.size(); ++i)
	{
		if (i < A.size()) 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;
}

另外一种思路，默认将A作为更长的大整数，也就是当A的长度小于B的程度时，执行add(B, A)

// C = A + B
vector<int> add(vector<int>& A, vector<int>& B)
{
	vector<int> C;
	int t = 0; // 进位
	if (A.size() < B.size()) return add(B, A);
	for (int i = 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;
}

高精度减法

Ai - Bi - t：从最低位开始，每一位相减，再减去借位
若以上的值小于0，那么计算的结果为Ai - Bi - t + 10
若以上的值大于等于0，那么计算的结果为Ai - Bi - t
将以上的结果保存到t中，也就是每次计算的时候：t = A[i] - B[i] - t
对于最后的结果，可以用(t + 10) % 10处理：将t小于0以及t大于等于0的两种情况合并到一起

以上计算的前提是：A大于B。若A小于B， 则需要计算B - A。即保证被减数的绝对值大于减数

所以在进行计算前，需要比较两个数的大小：

  • 先比较长度，长度长的数更大
  • 若两数长度一样，那么从高位开始比较
    • 若 A i A_i Ai​ != B i B_i Bi​，则返回 A i A_i Ai​ > B i B_i Bi​这个表达式的结果
  • 若循环走完，函数还没有返回，那么返回true，表示A与B相等

以下模板只给出了两个正数相减的情况。若数字存在负数，此时可以转换为两数的绝对值相减或者相加，关于最后的符号问题，分情况讨论即可

需要注意的是：最后需要去除前导0

bool cmp(vector<int>& A, vector<int>& 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;
}

// 保证A > B
vector<int> sub(vector<int>& A, vector<int>& B)
{
    int t = 0;
    vector<int> C;
    for (int i = 0; i <= A.size(); ++i)
    {
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);
        if (t < 0) t = 1;
        else t = 0;
    } 
    // 去除前导0
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

高精度乘法

注意：只有一个数是高精度的，另一个数比较小
A * b，len(A) <= 10，b <= 10000
将b看成一个整体和A相乘，而不是A和b一位一位的相乘

用t保存每一次b和 A i A_i Ai​相乘的结果，同时加上进位，注意t同时也是进位，且t的初值为0
即t += A[i] * b，t / 10为下一次计算的进位，t % 10为C需要保存的结果，保存的顺序从低位开始到高位

当 A n A_n An​的每一位和b相乘完后，可能还留有进位，即t不为0，此时仍然需要对t进行% 10 / 10的操作，直到t为0

可以通过以下具体例子，推演高精度乘法的过程
image.png

// 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;
}

注意：乘法运算结果，也需要去除前导0！

高精度除法

同样，A为高精度，而b是较小的数

  1. 从最高位 A i A_i Ai​开始，此时余数为0，将余数乘以10，加上 A i A_i Ai​，作为新的被除数
  2. 将被除数除以b，商作为结果的第一位（最高位 ），保留被除数模b的余数
  3. 将余数乘以10，加上 A i − 1 A_{i-1} Ai−1​。得到新的被除数，商作为结果的第二位，保留除数模b的余数…
  4. 直到走到A的最低位，此时的余数为整个结果的余数

可以发现，余数和被除数之间存在着一种转换关系，这里用r表示余数与被除数
由于我们使用数组的低位保存大整数的低位，而除法运算中，我们每次得到的是结果的高位。并且整数的高位到数组的低位上，所以最后需要反转字符串。同时，需要去除前导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 = r * 10 + 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;
}

前缀和

数组 a n a_n an​，前缀和 S i S_i Si​就是累加 a 1 a_1 a1​到 a i a_i ai​

如何求Si？
公式： S i S_i Si​ = S i − 1 S_{i-1} Si−1​ + a i a_i ai​

作用？
快速的求出原数组中某一区间的和，sum[l, r] = S r S_r Sr​ - S l − 1 S_{l-1} Sl−1​

二维前缀和

公式： S i j S_{ij} Sij​ = a i j a_{ij} aij​ + S i − 1 , j S_{i-1,j} Si−1,j​ + S i , j − 1 S_{i,j-1} Si,j−1​ - S i − 1 , j − 1 S_{i-1,j-1} Si−1,j−1​

差分

给定数组 a n a_n an​，构造 b n b_n bn​数组使得 a n a_n an​数组是 b n b_n bn​数组的前缀和
b 1 b_1 b1​ = a 1 a_1 a1​ - a 0 a_0 a0​
b 2 b_2 b2​ = a 2 a_2 a2​ - a 1 a_1 a1​
b n b_n bn​ = a n a_n an​ - a n − 1 a_{n-1} an−1​，注意 a 0 a_0 a0​的值为0，这是假设的
但是构建差分数组不使用以上方法，以上只是差分数组的性质。构建差分数组则是利用这一性质：

若现在有操作需要对[ a l a_l al​, a r a_r ar​]中的所有数加上c。此时可以不对 a n a_n an​进行操作，而对其差分数组 b n b_n bn​进行操作

因为 a n a_n an​是 b n b_n bn​的前缀和数组，若 b l b_l bl​ + c，那么 a l a_l al​ + c， a l + 1 a_{l+1} al+1​ + c， a r a_r ar​ + c。因为 a r + 1 a_{r+1} ar+1​不需要+c。因此 b r + 1 b_{r+1} br+1​ - c，使得 a r + 1 a_{r+1} ar+1​不变。这样操作就只用O(1)的时间完成了需要对 a n a_n an​数组的O(n)操作

差分数组的构造，假定原矩阵 a n a_n an​元素全为0，然后将 a i a_i ai​插入到区间[i, i]中，此时修改 b i b_i bi​为 b i b_i bi​ + a i a_i ai​，修改 b i + 1 b_{i+1} bi+1​为 b i + 1 b_{i+1} bi+1​ - a i a_i ai​

对于差分，不需要考虑如何构造，只需要考虑如何更新即可。以上方法是一种特殊的更新，可以用于差分的构造

差分模板：

// 核心是insert操作，对原数组的某段区间加上某个值
void insert(int l, int r, int c)
{
	b[l] += c;
	b[r + 1] -= c;
}

至于原数组 a n a_n an​怎么求，对差分数组 b n b_n bn​用前缀和公式即可

二维差分

同样，构造即更新，所以先理解更新：
若给定一个二维矩阵，矩阵中i行j列的元素用 a i j a_{ij} aij​表示，现需要对矩阵中以[ x 1 x_1 x1​, y 1 y_1 y1​]为左上角，以[ x 2 x_2 x2​, y 2 y_2 y2​]为右下角中的所有元素加上某个值，要怎么做？

根据 a i j a_{ij} aij​矩阵构造其差分矩阵 b i j b_{ij} bij​，其中 a i j a_{ij} aij​矩阵为 b i j b_{ij} bij​矩阵的前缀和。
当 b x 1 , y 1 b_{x_1, y_1} bx1​,y1​​ + c时， a i j a_{ij} aij​矩阵中，满足i >= x 1 x_1 x1​ && j >= y 1 y_1 y1​的所有元素都变成： a i , j a_{i, j} ai,j​ + c。
而需要+ c的区间为[ x 1 x_1 x1​, y 1 y_1 y1​]到[ x 2 x_2 x2​, y 2 y_2 y2​]，所以对于满足i >= x 2 x_2 x2​ || j >= y 2 y_2 y2​的元素，需要保持原样，现在它们的值为 a i , j a_{i, j} ai,j​ + c，需要修改为 a i , j a_{i, j} ai,j​ + c - c
此时需要修改差分数组， b x 2 + 1 , y 1 b_{x_2+1, y_1} bx2​+1,y1​​ - c， b x 1 , y 2 + 1 b_{{x_1}, y_2+1} bx1​,y2​+1​ - c， b x 2 + 1 , y 2 + 1 b_{x_2+1, y_2+1} bx2​+1,y2​+1​ + c
此时该差分矩阵推导出的原矩阵中，以[ x 1 x_1 x1​, y 1 y_1 y1​]为左上角，以[ x 2 x_2 x2​, y 2 y_2 y2​]为右下角中的所有元素都 + c

二维差分模板：

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

image.png

高精度练习题

791. 高精度加法

791. 高精度加法 - AcWing题库
image.png

输入的处理：用string获取两个加数A和B，将加数的低位放到数组的低下标处，高位放到数组的高下标处

用高精度加法模板进行加法运算

#include <iostream>
#include <string>
#include <vector>
using namespace std;

vector<int> add(vector<int>& A, vector<int>& B)
{
    vector<int> C;
    int t = 0;
    for (int i = 0; i < A.size() || i < B.size(); ++i) 
    {
        if (i < A.size()) 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;
    cin >> a >> b;
    vector<int> 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');
    
    vector<int> C = add(A, B);
    for (int i = C.size() - 1; i >= 0; --i) printf("%d", C[i]);
    return 0;
}

792. 高精度减法

792. 高精度减法 - AcWing题库
image.png
image.png

我认为cmp的判断写得很巧妙，两个判断都是当不等于的时候，返回一个比较的结果
这样子处理的逻辑也更清晰
以及，当A < B时，为了不写花括号，y总甚至写了逗号表达式，怎么说，这样子处理也是不错的吧

#include <iostream>
#include <string>
#include <vector>
using namespace std;

string a, b;
vector<int> A, B;

bool cmp(vector<int>& A, vector<int>& 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;
}

// 保证A > B
vector<int> sub(vector<int>& A, vector<int>& B)
{
    int t = 0;
    vector<int> C;
    for (int i = 0; i <= A.size(); ++i)
    {
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);
        if (t < 0) t = 1;
        else t = 0;
    } 
    // 去除前导0
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

int main()
{
    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');
    vector<int> C;
    if(cmp(A, B)) C = sub(A, B);
    else C = sub(B, A), printf("-");
    
    for (int i = C.size() - 1; i >= 0; --i) printf("%d", C[i]);
    
    return 0;
}

793. 高精度乘法

793. 高精度乘法 - AcWing题库
image.png

#include <iostream>
#include <string>
#include <vector>
using namespace std;

string a;
vector<int> A;
int b;

vector<int> mul(vector<int>& A, int b)
{
    int t = 0;
    vector<int> C;
    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;
}

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

794. 高精度除法

794. 高精度除法 - AcWing题库
image.png

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

using namespace std;
vector<int> A;
string a;
int b, r;

vector<int> div(vector<int>& A, int b, int& r)
{
    r = 0;
    vector<int> C;
    for (int i = A.size() - 1; i >= 0; --i)
    {
        r = r * 10 + 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()
{
    cin >> a >> b;
    for (int i = a.size() - 1; i >= 0; --i) A.push_back(a[i] - '0');
    
    auto C = div(A, b, r);
    for (int i = C.size() - 1; i >= 0; --i) printf("%d", C[i]);
    printf("\n%d", r);
    
    return 0;
}

前缀和练习题

795. 前缀和

795. 前缀和 - AcWing题库
image.png
给定一个数组，获取该数组后，根据其询问的区间返回区间和
利用前缀和数组的预处理，从 a n a_n an​数组得到 S n S_n Sn​前缀和数组
当询问[l, r]的区间和时，只要返回 S r S_r Sr​ - S l − 1 S_{l-1} Sl−1​

#include <iostream>
using namespace std;

const int N = 1e6 + 10;
int a[N] = {0}, S[N] = {0};
int n,m;
int l,r;

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) S[i] = S[i - 1] + a[i];
    
    while (m--)
    {
        scanf("%d%d", &l, &r);
        printf("%d\n", S[r] - S[l - 1]);
    }
    
    return 0;
}

796. 子矩阵的和

796. 子矩阵的和 - AcWing题库
image.png

利用二维前缀和的公式即可解题

#include <iostream>
using namespace std;

const int N = 1010;
int a[N][N] = {0}, S[N][N] = {0};
int n, m, q;
int x1, y1, x2, y2;

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)
            S[i][j] = a[i][j] + S[i - 1][j] + S[i][j - 1] -S[i - 1][j - 1];
            
    // 处理询问
    while (q--)
    {
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        printf("%d\n", S[x2][y2] - S[x2][y1 - 1] - S[x1 - 1][y2] + S[x1 - 1][y1 - 1]);
    }
    return 0;
}

差分练习题

797. 差分

797. 差分 - AcWing题库
image.png

题目输入原数组 a n a_n an​，我们用特殊的更新构建其差分数组 b n b_n bn​。对于原数组的区间操作，只要修改差分数组即可，最后根据差分数组使用前缀和公式推导原数组即可

#include <iostream>
using namespace std;

const int N = 1e6 + 10;
int a[N], b[N] = {0};
int n, m;
int l, r, c;

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

int main()
{
    scanf("%d%d", &n, &m);
    // 获取a数组
    for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
    // 构造其差分数组
    for (int i = 0; i < n; ++i) insert(i, i, a[i]);
    
    while (m--)
    {
        scanf("%d%d%d", &l, &r, &c);
        insert(l - 1, r - 1, c);
    }
    
    // 推导a数组
    for (int i = 1; i < n; ++i) b[i] += b[i - 1];
    // 打印最终数组 
    for (int i = 0; i < n; ++i) printf("%d ", b[i]);
    return 0;
}

所以还可以这样解：

#include <iostream>
using namespace std;

const int N = 1e6 + 10;
int a[N] = {0}, b[N] = {0};
int n, m;
int l, r, c;

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

int main()
{
    scanf("%d%d", &n, &m);
    // 获取a数组
    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--)
    {
        scanf("%d%d%d", &l, &r, &c);
        insert(l, r, c);
    }
    
    // 推导a数组
    for (int i = 1; i <= n; ++i) a[i] = (b[i] += b[i - 1]);
    // 打印最终数组
    for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
    return 0;
}

其实可以不用创建 a n a_n an​数组，直接使用 S n S_n Sn​数组即可

#include <iostream>
using namespace std;

const int N = 1010;
int S[N][N] = {0};
int n, m, q;
int x1, y1, x2, y2;

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--)
    {
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        printf("%d\n", S[x2][y2] - S[x2][y1 - 1] - S[x1 - 1][y2] + S[x1 - 1][y1 - 1]);
    }
    return 0;
}

798. 差分矩阵

798. 差分矩阵 - AcWing题库
image.png

#include <iostream>
using namespace std;

const int N = 1010;
int n,m,q;
int x1, y1, x2, y2, c;
int a[N][N] = {0}, b[N][N] = {0};

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

int main()
{
    scanf("%d%d%d", &n, &m, &q);
    
    // 获取a矩阵
    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--)
    {
        scanf("%d%d%d%d%d", &x1, &y1, &x2, &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;
}

这里最好将差分数组以及原数组的i = 0以及j = 0的位置初始化为0并且不使用，从下标为1的位置开始使用数组。因为最后推导原数组中，需要用到这些下标为0的元素

.SacaJawea
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法基础课——第一章 基础算法（二）
m0_62021646的博客
07-04 616
高精度问题其实只有使用 C++ 编程语言的同学需要关注，使用 java 或 python 编程语言的同学不需要太多关注。因为 java 有大整数类，python 自带的数据范围默认就是无限大，而 C++ 没有相对应的处理大整数运算的数据结构。高精度的考察主要分为四种：高精度{加法A+B减法A−B乘法A×a除法A÷a高精度\begin{cases}加法 \quad A+B \\ 减法 \quad A-B \\ 乘法 \quad A \times a \\ 除法 \quad A \div a\end{cases
某学长讲课ppt（前缀和与差分，二维前缀和与差分）
03-23
二维前缀和与差分的计算：在一维的基础上，进一步讲解二维前缀和与差分的计算方法，结合图表和实例，展现其在图像处理、矩阵计算等领域的应用价值。 应用示例：通过算法竞赛、数据处理等实际场景中的应用案例，展示...
AcWing第一章算法模板总结——基础算法
weixin_43389219的博客
05-07 517
一、排序算法二、二分三、高精度四、前缀和与差分五、位运算六、双指针算法七、离散化八、区间合并。
acwing算法基础课-第一章 基础算法
偶然路过的帅小伙z的博客
04-13 751
排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并
AcWing算法基础课笔记 第一章 基础算法
shaozheng0503的博客
03-14 836
​编辑快速排序算法模板 —— 模板题 AcWing 785. 快速排序 归并排序算法模板 —— 模板题 AcWing 787. 归并排序 整数二分算法模板 —— 模板题 AcWing 789. 数的范围 浮点数二分算法模板 —— 模板题 AcWing 790. 数的三次方根 高精度加法 —— 模板题 AcWing 791. 高精度加法 高精度减法 —— 模板题 AcWing 792. 高精度减法 高精度乘低精度 —— 模板题 AcWing 793. 高精度乘法 高精度除以低精度 —— 模板题
蓝桥杯Python组算法合集（ 二分、倍增、前缀和与差分等）
04-13
"蓝桥杯Python组算法合集"就是针对这类需求提供的一份资源，它涵盖了二分查找、动态规划倍增、前缀和与差分计算等基础但实用的算法。这些算法在解决复杂问题时能起到关键作用，下面我们将详细探讨这些知识点。 首先...
前缀和与差分算法地深入理解
07-11
本文将深入讨论前缀和的概念、二维前缀和、差分和差分矩阵，并探讨它们在算法设计中的应用。 一、前缀和 前缀和是指数组中某个位置之前的元素之和。设数组a：a[1],a[2],…,a[n]，则其前缀和数组s：s[i] = a[1] + a...
C++算法：前缀和基础
10-15
preSum[i]记录子数组[0,i)的和。比如：nums = {1,2,3,4},则preSum = {0,1,3,6,10}。通过preSum，我们可以求任意nums的子数组和。子数组[i,j)等于子数组[0,j)减去[0,i)，也就是子数组[i,j)的和等于preSum[j] – ...
Acwing-基础算法-第一章-基础算法
03-24
本章节主要讲解了一维和二维的基础算法，包括前缀和、差分、最长子序列、双指针算法以及二进制运算等核心概念，旨在帮助学习者建立扎实的算法基础。 1. **前缀和** 前缀和是一种利用空间换取时间的技术，常用于...
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 193
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 429
算法014：找到字符串中所有字母异位词
排序算法(4)之快速排序(1)
最新发布
wer24_25的博客
07-17 722
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 77
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 207
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 871
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
树与二叉树
2201_76027754的博客
07-15 760
树和二叉树
排序思想-快排
m0_58257626的博客
07-17 127
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
hanmo22357的博客
07-12 834
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值