AcWing 算法基础课第二节基础算法2高精度、前缀和与差分

已于 2022-10-25 16:15:54 修改
阅读量522 收藏 1
点赞数 1
分类专栏： 算法基础 ACWing 文章标签： 算法 c++
于 2022-09-04 22:21:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44946232/article/details/126443752
版权

1、该系列为ACWing中算法基础课，已购买正版，课程作者为yxc
2、y总培训真的是业界良心，大家有时间可以报一下
3、为啥写在这儿，问就是oneNote的内存不够了QAQ

ACwing C++ 算法笔记2 基础算法


本节内容：高精度、前缀和与差分

一、高精度

java和python 有大整数类，可以不需要学习高精度。

1.1 应用场景

  • 高精度的考试方式有4种：

    • 1、比较大的整数相加A+B ，A/B 的位数在1e6
    • 2、比较大的整数相减A-B，A/B 的位数在1e6
    • 3、大整数乘以小整数A*a，A 的位数小于等于1e6，a的数值小于等于1e9
    • 4、大整数除以小整数A/a

  • 高精度整数以数组的形式存储，个位存在前面，高位存在后面，方便做加法和乘法的时候进位。

1.2 高精度加法

  • 高精度加法模拟的是手动相加的顺序。
  • 举例：1≤整数长度≤100000，给定两个正整数（不含前导 0），计算它们的和。
// 高精度加法
// C = A + B, A >= 0, B >= 0
#include <iostream>
#include <vector>

using namespace std;

vector<int> add(vector<int> &A, vector<int> &B)
{
    if (A.size() < B.size()) return add(B, A);
    
    vector<int> C;
    int t = 0;
    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(t); // 最高位还有进位
    return C;
}
int main()
{
    string a, b;
    vector<int> 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');
    
    auto c = add(A, B);
    for (int i = c.size()-1; i >=0; i -- ) printf("%d", c[i]);
    
    return 0;
}

1.3 高精度减法

  • 加减法存储方式是相同的。
  • 流程：
    • 如果A<B，计算-(B-A)，可以保证计算时最高位不用借位。
    • 判断是否需要借位：
      在这里插入图片描述
// 高精度减法
// C = A - B, 满足A >= B, A >= 0, B >= 0
#include <iostream>
#include <vector>

using namespace std;

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)  // C = A - B, 满足A >= B, A >= 0, B >= 0
{
    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) % 10);  // 不论是否借位可以合二为一的写
        if (t < 0) t = 1;            // 有借位
        else t = 0;					 // 不需要借位
    }
    
	// 去掉高位的0(例如123-120 = 003)
    while (C.size() > 1 && C.back() == 0) C.pop_back();  
    return C;
}


int main()
{
    string a, b;
    vector<int> 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);
        for (int i = c.size()-1; i >=0; i -- ) printf("%d", c[i]);
    }
    else
    {
        auto c  = sub(B, A);
        printf("-");
        for (int i = c.size()-1; i >=0; i -- ) printf("%d", c[i]);
    }

    return 0;
}

1.3 高精度乘法

  • 高精度乘法时的当前位数和进位
    在这里插入图片描述
    在这里插入图片描述

  • 举例：123 x 12，这里的乘法把B 视为一个整体;
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    因此答案为1476；

  • 代码：

// 高精度乘低精度
// C = A * b, A >= 0, b > 0
#include <iostream>
#include <vector>

using namespace std;

vector<int> mul(vector<int> &A, int b)
{
    vector<int> C;
    int t = 0;
    
    // 要么i没有循环完，要么t不为0 (||t)（进位没有处理完）.
    for (int i = 0; i < A.size() || t; i ++ )
    {
        if (i < A.size()) t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }
    return C;
}

int main()
{
    string a;
    int b;
    cin >> a >> b;
    
    if (b==0) 
    {
        cout << '0' << endl;
        return 0;
    }
    
    vector<int> A;
    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;
}
  • 注意：相乘的循环条件，要么i没有循环完，要么t不为0（进位没有处理完）

1.4 高精度除法

  • 假设是A3A2A1A0除以b：
    在这里插入图片描述
  • 除法：一般正着存数组会好算。
// 高精度除以低精度
// A / b = C ... r, A >= 0, b > 0

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

using namespace std;

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;
    }
    // 翻转前C0是最高位，C1是最低位
    reverse(C.begin(), C.end());
    
    // 去前导0
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    
    return C;
}

int main()
{
    string a;
    int b;
    cin >> a >> b;

    vector<int> A;
    for (int i = a.size()-1; i >= 0; i -- ) A.push_back(a[i]-'0');
    
    int r;
    auto C = div(A, b, r);
    
    for (int i=C.size()-1; i>=0; i--) printf("%d", C[i]);
    cout << endl;
    cout << r << endl;
    
    return 0;
}

1.5 高精度x高精度

高精度 X 高精度
#include <iostream>
#include <vector>

using namespace std;

vector<int> mul(vector<int> &A, vector<int> &B) {
    vector<int> C(A.size() + B.size() + 7, 0); // 初始化为 0，C的size可以大一点

    for (int i = 0; i < A.size(); i++)
        for (int j = 0; j < B.size(); j++)
            C[i + j] += A[i] * B[j];

    int t = 0;
    for (int i = 0; i < C.size(); i++) { // i = C.size() - 1时 t 一定小于 10
        t += C[i];
        C[i] = t % 10;
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back(); // 必须要去前导 0，因为最高位很可能是 0
    return C;
}

int main() {
    string a, b;
    cin >> a >> b; // a = "1222323", b = "2323423423"

    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');

    auto C = mul(A, B);

    for (int i = C.size() - 1; i >= 0; i--)
        cout << C[i];

    return 0;
}

二、前缀和与差分

前缀和与差分是一对逆运算。

2.1 前缀和

2.1.1 一维前缀和

  • 如果有一个数组a1...an，其前缀和数组si定义为si = a1+ a2+ a3+...+ai，注意前缀和的下标从1开始，s0 = 0；
  • 如何求si ？从前往后for循环一遍。for (i=1; i<=n; i++) { s[i] = s[i-1] + a[i] }
  • si的作用：快速的求出原数组中一段数的和，如求出a[l]到a[r]的和，只需计算s[r] - s[l-1]。
  • 定s0 = 0可以处理边界，例如计算[1,10]的前缀和，是s10 - s0 = s10，可以用相减的方式来表示，不需要特判。
 一维前缀和
S[i] = a[1] + a[2] + ... a[i]
a[l] + ... + a[r] = S[r] - S[l - 1]

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

using namespace std;

const int N = 100010;

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

int main()
{
	// ios::sync_with_stdio(false);
	
    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 -- )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        printf("%d\n", s[r] - s[l-1]); // 区间和的计算
    }
    
    return 0;
}
  • ios::sync_with_stdio(false);让cin和标准输入输出不同步，提高cin的读取速度，但是会干扰文件操作，且不能再使用scanf。
  • 数据规模大于100,0000建议用scanf，否则用cin。

2.1.2 二维前缀和

  • 一维前缀和，可以快速的求出区间的和；二维前缀和，可以快速的求出子矩阵的和；
  • sij表示左上角所有区域的和；
    在这里插入图片描述
  • 求出子矩阵的和：s(x2, y2 )- s(x2, y1-1) - s(x1-1, y2) + s(x1-1, y1-1)
    在这里插入图片描述
  • 计算二维前缀和矩阵元素sij（已知其左上角的前缀和）：for (i: 1~n ) { for (j: 1~m) { sij = s(i-1, j) + s(i, j-1) - s(i-1, j-1) + aij }}（红色加绿色面积减去重叠的面积加上aij元素面积）
二维前缀和
S[i, j] = 第i行j列格子左上部分所有元素的和
以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵的和为 S[x2, y2] - S[x1 - 1, y2] - S[x2, y1 - 1] + S[x1 - 1, y1 - 1]

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

const int N = 1010;
int n, m, q;

int a[N][N], 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", &a[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] + a[i][j]; // 求前缀和
    
    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;
}

2.2 差分

2.2.1 一维差分

  • 差分是前缀和的逆运算；
  • 假设有数组a1,a2,...,an要构造b1, b2,...,bn，使得ai = b1+b2+...+bi，则b称为a的差分(b2+a1 = a2)，a称为b的前缀和。（同理的表述：b1 = a1,b2=a2-a1,b3=a3-a2,…,bn = an-a(n-1)）
  • 差分的用处：
    • 1、只要有b数组，就可以用O(n)的时间得到数组a；
    • 2、利用差分在O(1)的时间内，让前缀和A数组[l,r]范围内的数都加c（ 假设给定一个数组 A ，其差分数组为 B， 如果对A数组的某个区间 [l, r]上每个数都加一个数c， 其等价于 B 数组中 B[l] += c，且 B[r + 1] -=c。因为A[l]表示B[l]的前缀和，则如果B[l]多加一个c（B[l] += c），则A[l], A[l+1], …, A[r], A[r + 1], …, A[n] 都将多加一个c。而我们只需要 [l, r] 上加c，所以对于 A 在 [r+1, n]区间上的值再减去 c，即对应于 B[r + 1] -= c)
    • 其实可以直接按照原始的方法，依次遍历前缀和A数组的 [l, r] 区间，并执行 A[i] += c，但每次的操作的时间复杂度都是O(n)。使用insert差分方法，则可以将每次操作转换为一个公式即可，即时间复杂度变为 O(1)。修改前缀和的某个连续区间范围内的值，可以转化为只需要修改其差分数组的某两个值。 差分能够优化的方式在于，不用每次操作都进行循环，可完成每轮操作修改其差分数组的两个值后，统一进行循环。
      在这里插入图片描述
  • 3、当其前缀和数组为[a1, a2, ... , an]时，想要得到差分数组b的值，可以通过模拟在n位全零数组B[0, 0, ... ,0]的B[i, i]中插入a[i]得到，即insert(i, i, a[i]);，且进行了n次插入操作。例如：前缀和数组为{1 2 2 1 2 1}经过插入得到差分数组{1 1 0 -1 1 -1 }。同时该insert操作可以让前缀和数组a的某一段+c，并让两种功能都通过同一个函数实现。
 B[i] = a[i] - a[i - 1]   // (i>1)
 给区间[l, r]中的每个数加上c：B[l] += c, B[r + 1] -= c (a[r]之后的不能加上c)
  • 举例：输入一个长度为 n 的整数序列。接下来输入 m 个操作，每个操作包含三个整数 l,r,c，表示将序列中 [l,r] 之间的每个数加上 c。请你输出进行完所有操作后的序列。
#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);
    // 前缀和和差分数组下标都是从1开始，为了方便
    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);
    
    // 这里的insert求的是a的差分数组,刚开始差分数组b的初始化全为0
    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.2.2 二维差分

  • 给差分矩阵的子矩阵都+c：

    • b(x1, y1)+c的效果是，这个点右下角所有值都+c
      在这里插入图片描述

    • b(x1, y2+1)-c的效果是，这个点右边所有值都-c
      在这里插入图片描述

    • b(x2+1, y1)-c的效果是，这个点下面所有值都-c
      在这里插入图片描述
      在这里插入图片描述

    • 因此可以转化为：
      在这里插入图片描述

  • 因此前缀和矩阵的a(i,j)可以想象为给差分矩阵的1x1大小的子矩阵进行插入操作得到的。

给以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵中的所有元素加上c：
S[x1, y1] += c, S[x2 + 1, y1] -= c, S[x1, y2 + 1] -= c, S[x2 + 1, y2 + 1] += c
  • 举例：输入一个 n 行 m 列的整数矩阵，再输入 q 个操作，每个操作包含五个整数 x1,y1,x2,y2,c，其中 (x1,y1) 和 (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。每个操作都要将选中的子矩阵中的每个元素的值加上 c。请你将进行完所有操作后的矩阵输出。
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

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

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);
    
    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, c;
        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]);
        puts("");
    }
        
    return 0;
}
  • 代码中a和b两个数组都是全局变量，全局变量有一个特性就是在定义时编译器会自动将数组中的元素全部初始化为0。而a和b两个等长的0数组是满足差分关系的，也就是满足b是a的差分数组，a是b的前缀和数组。
  • 代码中是将a的实际初始状态看做是在全0的初始状态下对a进行插入而得到，此时在a插入的同时对b矩阵的状态进行更新，得到实际a的初始状态下对应的b矩阵。
  • 接下来就是题目要求的对a矩阵的一个子矩阵进行插入操作，在这里我们不直接对a进行更新，而是对b矩阵进行跟新，最终根据得到的b矩阵来反求出a矩阵。
雪团子
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
loadrunner课堂笔记
10-13
loadrunner课堂笔具体步骤
AcWing 算法基础课 并查集（持续更新中···）
峰峰爱吃肉
11-02 771
并查集 处理多个元素的集合问题，主要解决元素分组问题，支持合并和查询两种操作。原理是一个集合是一棵树，根节点就是所有儿子的祖宗。 模板题链接：AcWing 836.合并集合 初始化:最开始每个点都是一个集合，一般把每个集合初始为它本身。一般用并查集这种数据结构的时候，最开始就要把它初始化，时间复杂度为O(n)O(n)O(n)，模板代码如下 void init() { for(int i=1;i<=n;++i) p[i]=i; } 返回元素x的祖宗结点---find()函数，注意根节点一定有
2022年寒假（2022.1.9-2022.2.20）总结
008
02-25 1300
一些收获： 1.get1000块的红包，但是我立马就拿去买课了。报了acwing的基础课和提高课，一下子就去了500，然后报了蓝调口琴网的基础班500转瞬即逝。看盗版课程虽然省钱，但不可以提交代码，总觉得心里还是虚的hh。还报了y总的寒假每日一题，不过只ac了两道题hh，又开始二刷基础课的内容。 2.自己打算练练绘画，然后开始跟着kk幼儿园画画了。寒假我基本上只干了三件事，一个是学习新概念，一个是学画画，一个是写算法。 3.练了几天的线条，然后开始抓型训练了，九宫格->定点->多边形...
AcWing-244.谜一样的牛
ZzzzGgggHhhh的博客
01-04 231
题解： 从后往前依次判断牛的高度，当前牛之前有a个牛比它低，则当前牛的最低身高为a+1，所以当前牛的高度为所有牛的第a+1低，然后二分判断当前所有牛中第a+1，低的牛身高为多少，当前每头牛被选走之后，记录一下。 用树状数组维护牛身高的序列，前缀和求第几高，当牛被选走之后，该身高位置减一即可。 #include<stdio.h> #include<algorithm> us...
AcWing提高算法课Level-3 第四章 高级数据结构
小哈里的博客
09-23 749
AcWing提高算法课Level-3 第四章 高级数据结构 并查集 AcWing 1250. 格子游戏1167人打卡 AcWing 1252. 搭配购买1064人打卡 AcWing 237. 程序自动分析940人打卡 AcWing 239. 奇偶游戏629人打卡 AcWing 238. 银河英雄传说844人打卡 树状数组 AcWing 241. 楼兰图腾1083人打卡 AcWing 242. 一个简单的整数问题1050人打卡 AcWing 243. 一个简单的整数问题2916人打卡 AcWing 244.
acwing基础算法
恁村扛把子的博客
11-29 6561
文章目录基础算法快速排序归并排序整数二分浮点数二分高精度加法高精度减法高精度乘法高精度除法一维前缀和 —— 模板题二维前缀和 —— 模板题一维差分 —— 模板题二维差分 —— 模板题 基础算法 快速排序 void quick_sort(int q[], int l, int r) { if(l >= r)return; int i = l - 1, j = r + 1, x = q...
Acwing - 算法基础课 - 笔记（贪心 · 二）
vcj1009784814的博客
01-05 1015
文章目录贪心（二）排序不等式绝对值不等式推公式 贪心（二） 这是算法基础课的最后一节，预计先把后面几道贪心的例题讲完，随后讲解一下时间复杂度的分析。 排序不等式 Acwing - 913. 排队打水 假设各个同学的打水时间为：3 6 1 4 2 5 7 并且就按照这个顺序来打水。 当第一个同学打的时候，后面所有同学都要等他，所以等待的总时长要加上一个3 * 6，第二个同学打的时候，后面所有同学也都要等他，所以要加上个6 * 5，以此类推，所有同学等待的总时长为 3 * 6 + 6 * 5 + 1 * 4 +
AcWing-算法提高课【合集】
热门推荐
violet的博客
08-29 1万+
先打基础再提高
Acwing算法课程/模板代码 学习理解
LJ的博客
09-06 2097
文章目录算法基础课`数据结构`排序快速排序归并排序二分查找整数浮点数高性能Ope加减法乘除法前缀和/差分一维二维位运算双指针离散化区间合并`数据结构`链表栈队列KMPTrie树并查集堆哈希图 [ACWing](https://www.acwing.com/blog/content/405/)图的存储图的遍历拓扑排序图的最短路径图的最小生成树二分图的判别二分图的最大匹配数学知识动态规划贪心算法提高算法进阶 太穷了，只看看模板代码吧 算法基础课 数据结构 排序 快速排序 归并排序 二分查找 整数 浮点数 高
acwing算法基础课讲义
04-30
acwing算法基础课讲义
acwing和leetcode-algo:某物
07-07
acwing和leetcode 暂时计划： 每天刷: 巩固以及熟悉 每日必刷 2021.6.25： DP: 前面的也要刷 第一期：2021/4/5 之前： 11 94 102 104 111 121 144 145 2021/4/5开始，每天刷： (3月份每日一题) (3月份每日一题) | 链表的插入，快速排序 笔试算法面试辅导课 笔试 DP 待补充 记录我的刷题进度 目录： 尝试过 【建议前端必刷】 用 js 刷LeetCode 算法专题（全） 「leetcode-javascript 」适合前端小伙伴的刷题路线，全程使用的语言是 JavaScript 已废弃 没有坚持下去... 每日一学计划： 2021-1-16： 并查集 2021-1-17： Trie 2021-1-18： 前缀和 2021-1-19： dfs && bfs 2021-1-20： 链表
老毛子百度云转存【2019-1-22】.txt
03-16
老毛子百度云转存工具 可以批量导入资源列表，支持密码，批量转存到自己的网盘。 转存结果可以导出。 附件是百度网盘地址。
AcWingTraining:在AcWing平台学习算法总结
03-26
培训 在AcWing平台学习算法总结
Acwing 算法基础课超详细笔记
11-27
Acwing 算法基础课超详细笔记
AcWing 基础算法课.md
10-11
AcWing 基础算法课.md
AcWing算法基础课模板大全
07-14
前缀和与差分 双指针算法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 栈与队列：单调队列、单调栈 kmp Trie 并查集 堆 Hash表 搜索与图论 —— ...
acwing基础算法模板整理
02-27
算法整理，包括但不限于基础算法，数据结构，搜索图论以及数学知识
笔试强训-day17_T2 十字爆破
最新发布
weixin_46186903的博客
05-03 433
模拟即可，但是由于数据量过⼤，我们可以提前把每⼀⾏以及每⼀列的和存起来，⽅便统计总和。解法二：提前把每⼀⾏以及每⼀列的和存起来，然后输入输出使用快速的IO方式，解答如下所示。解法一：暴力遍历，这种方法很容易想到，并且也容易编写出代码，但是会超时。因为1+2+3=6，1+2+4=7，1+3+4=8，2+3+4=9。牛牛选择一个方格，可以得到和这个方格同行、同列的所有数之和的得分。现在牛牛想知道下一步选择每个格子的得分情况，你可以帮帮他吗？m个方格，每个方格中有一个整数。
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 171
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
acwing算法基础课网盘
07-13
### 回答1： acwing算法基础课是一门针对算法学习的在线课程，在这门课程中，学生可以系统地学习和掌握算法基础知识，提高编程水平。为了方便学生学习，acwing提供了网盘服务。 acwing算法基础课网盘是一个用于存储课程资源的平台。通过这个网盘，学生可以下载课程讲义、代码模板以及补充材料等。这些资源都经过精心整理，供学生们参考和学习。 网盘中的资源是按照课程章节进行分类的，学生可以根据自己的学习需要，选择性地下载所需的资料。同时，网盘还提供了搜索功能，方便学生快速定位和获取所需资料。 acwing算法基础课网盘的使用对于学生们的学习非常有帮助。通过下载和学习这些资源，学生们可以更好地理解课程内容，加深对算法的理解。此外，学生们还可以通过研究代码模板，学习优秀的编程思想和技巧，提高自己的编程能力。 总之，acwing算法基础课网盘是一项非常便利和实用的服务，为学生们提供了更加全面和深入的学习资源，帮助他们更好地掌握和运用算法知识。 ### 回答2： acwing算法基础课是一门优质的算法学习资源，其中的课程内容丰富多样，涵盖了算法基础知识、数据结构、动态规划、图论等等。很多学习者都认为这门课程对他们的算法学习有很大的帮助。 网盘是指以网络为媒介，提供文件存储和下载服务的云存储平台。acwing算法基础课也提供了网盘服务，方便学习者下载课程资料并进行学习。 通过acwing算法基础课网盘，学习者可以方便地获取到课程的各种学习资料，包括讲义、习题集、代码示例等。这些资料可以帮助学习者更好地理解和掌握课程的内容。此外，网盘还提供了上传和分享功能，学习者可以将自己的学习心得、代码等资料分享给其他学习者，促进学习者之间的互相学习和交流。 acwing算法基础课网盘的优点不仅仅是方便快捷的下载和分享功能，还包括安全可靠的存储环境。学习者可以放心地将自己的学习资料上传到网盘进行备份，减少数据丢失的风险。同时，网盘还提供了多种存储空间容量的选择，满足学习者不同的需求。 总的来说，acwing算法基础课网盘为学习者提供了方便、安全和多样化的学习资源下载和分享服务，为学习者的算法学习和进步提供了有力的支持。如果你对算法感兴趣，我推荐你去尝试一下这门精彩的课程！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值