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

news2025/2/21 22:00:42

文章目录

    • 高精度运算
      • 高精度加法
      • 高精度减法
      • 高精度乘法
      • 高精度除法
    • 前缀和
      • 二维前缀和
    • 差分
      • 二维差分
    • 高精度练习题
      • 791. 高精度加法
      • 792. 高精度减法
      • 793. 高精度乘法
      • 794. 高精度除法
    • 前缀和练习题
      • 795. 前缀和
      • 796. 子矩阵的和
    • 差分练习题
      • 797. 差分
      • 798. 差分矩阵

高精度运算

两个大数做运算，位数一般是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的元素

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

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

相关文章

Day37

Day37

思维导图 练习 1> 编写一个名为myfirstshell.sh的脚本&#xff0c;它包括以下内容。 a、包含一段注释&#xff0c;列出您的姓名、脚本的名称和编写这个脚本的目的 b、和当前用户说“hello 用户名” c、显示您的机器名 hostname d、显示上一级目录中的所有文件的列表 e、显示…
阅读更多...
Git 多账号多仓库配置 SSH

Git 多账号多仓库配置 SSH

前言 在我们使用 Git 中&#xff0c;有时候会遇到多账号多仓库的情况&#xff0c;比如公司的 GitLab 和 GitHub&#xff0c;以及自己的 GitHub&#xff0c;这时候我们就需要配置多个 SSH 密钥来区分不同的账号和仓库 生成 SSH 密钥 根据你注册仓库的邮箱生成 SSH 密钥&#…
阅读更多...
Kubeadm方式搭建K8s集群 1.27.0版本

Kubeadm方式搭建K8s集群 1.27.0版本

目录 一、集群规划 二、系统初始化准备(所有节点同步操作) 三、安装并配置cri-docker插件 四、安装kubeadm&#xff08;所有节点同步操作&#xff09; 五、初始化集群 六、Node节点添加到集群 七、安装网络组件Calico 八、测试codedns解析可用性 一、集群规划 环境规划…
阅读更多...
Qt 定时器

Qt 定时器

定时器事件---timerEvent 定时器启动 startTimer(); 注意&#xff1a;定时器参数要是全局或者静态变量。 定时器结束 没有结束函数 定时器标志---timerId int timerIdstartTimer(); startTimer()返回定时器标志 需设置为类的成员--类内使用 定时器使用 通过定时器事件…
阅读更多...
设计模式介绍

设计模式介绍

设计模式的分类 总体来说设计模式分为三大类&#xff1a; 创建型模式&#xff0c;共五种&#xff1a;工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式&#xff0c;共七种&#xff1a;适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式…
阅读更多...
JVM体系结构模块

JVM体系结构模块

1、类装载器ClassLoader &#xff08;1&#xff09;负责加载class文件&#xff0c;class文件在文件开头有特定的文件标示&#xff0c;并且ClassLoader只负责class文件的加载&#xff0c;至于它是否可以运行&#xff0c;则由Execution Engine决定 &#xff08;2&#xff09;加…
阅读更多...
麻了。。。

麻了。。。

同样的初始条件&#xff0c;一个每隔0.05s保存一步数据&#xff0c;一个每隔1.13s保存一步数据。 上面横轴代表时间&#xff0c;纵轴代表Nu。 可以看出其实是不太一样的&#xff0c;一个取平均是24.72&#xff0c;一个是25.34&#xff0c;差距其实有的。 我目前跑算例发现长时间…
阅读更多...
【C++】类和对象超全超详细总结（万字详解）

【C++】类和对象超全超详细总结（万字详解）

&#x1f680; 作者简介&#xff1a;一名在后端领域学习&#xff0c;并渴望能够学有所成的追梦人。 &#x1f681; 个人主页&#xff1a;不 良 &#x1f525; 系列专栏&#xff1a;&#x1f6f8;C &#x1f6f9;Linux &#x1f4d5; 学习格言&#xff1a;博观而约取&#xff0…
阅读更多...
C#视觉检测-模板匹配

C#视觉检测-模板匹配

前几天一个学员在学习C#与视觉交互时,也不知道视觉可以用来做什么 。下面我们就详细讲讲C# 和视觉交互的相关知识。 C#和Halcon的视觉交互在工业生产和智能制造领域中得到了广泛应用。其中&#xff0c;模板匹配是一种简单但有效的图像处理技术&#xff0c;可以用于检测和定位物…
阅读更多...
性能测试压测工具都有哪些？怎么选你知道吗？

性能测试压测工具都有哪些？怎么选你知道吗？

目录 普遍存在的问题 工具选型和推荐 软件测试而非测试工具 总结&#xff1a; 普遍存在的问题 聊压测工具之前&#xff0c;先聊一下我面试候选人时问的问题以及在技术交流群经常遇到的一个情况。 面试候选人特别是性能测试岗位&#xff0c;我一般很少问测试工具的问题&…
阅读更多...
53 最佳实践-安全最佳实践-虚拟机可信启动

53 最佳实践-安全最佳实践-虚拟机可信启动

文章目录 53 最佳实践-安全最佳实践-虚拟机可信启动53.1 概述53.2 配置vTPM设备&#xff0c;使能度量启动53.2.1 安装swtpm和libtpms软件53.2.2 虚拟机配置vTPM设备53.2.3 确认度量启动使能成功 53 最佳实践-安全最佳实践-虚拟机可信启动 53.1 概述 可信启动包含度量启动和远…
阅读更多...
深入篇【Linux】学习必备：谈gcc/g++使用及原理 + 动静态库介绍 + debug与release模式

深入篇【Linux】学习必备：谈gcc/g++使用及原理 + 动静态库介绍 + debug与release模式

深入篇【Linux】学习必备&#xff1a;谈gcc/g是如何完成程序的翻译过程&&动静态库介绍&&debug与release模式 Ⅰ.gcc/g是如何完成程序的翻译过程的&#xff1f;①.预处理(宏替换)②.编译(生成汇编)③.汇编(生成机器可识别代码)④.链接(生成可执行文件) Ⅱ.动态库…
阅读更多...
安装Nginx网站服务

安装Nginx网站服务

目录 前言 一、Nginx简介 二、Nginx应用场景 三、Nginx与Apache优缺点 1&#xff09;Nginx 相对于 Apache 的优点 2&#xff09;Apache 相对于 Nginx 的优点 3&#xff09;Nginx和Apache的差异 四、阻塞与非阻塞、同步与异步 五、安装Nginx软件 1、在线安装 ①使用y…
阅读更多...
半导体测试系统 芯片自动化测试软件 可定制测试方案ATECLOUD-IC

半导体测试系统 芯片自动化测试软件 可定制测试方案ATECLOUD-IC

*测试产品&#xff1a;芯片半导体器件。纳米软件ATECLOUD-IC芯片自动化测试系统适用于二极管、三极管、绝缘栅型场效应管、结型场效应管、单向和双向可控硅、普通和高速光耦、整流桥、共阴共阳二极管及多阵列器件等各类半导体分立器件综合性能自动化测试。 *被测项目&#xff…
阅读更多...
vue3 script setup

vue3 script setup

解决在使用vue 3 composition API(组合式API)时繁琐的问题&#xff0c;比如定义一个方法&#xff0c;模板需要使用该方法&#xff0c;就必须将方法返回&#xff0c;当组件中存在大量方法和属性时就很麻烦。 一、什么是script setup 二、script setup什么作用 1.自动注册子组件 …
阅读更多...
flutter 主题色彩管理组件 flex_color_scheme

flutter 主题色彩管理组件 flex_color_scheme

flutter 主题色彩管理组件 flex_color_scheme 前言 原文 https://ducafecat.com/blog/flutter-flex-color-scheme 平时我们做样式适配关心几个方面: 设计稿颜色 标记尺寸大小、比例 全局修改为主 快速可修改 今天将会介绍一个快速调整主题色彩样式的三方组件 flex_color_schem…
阅读更多...
[RocketMQ] NameServer启动流程源码解析 (一)

[RocketMQ] NameServer启动流程源码解析 (一)

文章目录 1.NameServer概述2.NamesrvStartup启动入口3.createNamesrvController创建NamesrvController3.1 创建NamesrvController 4.start启动NamesrvController4.1 初始化NettyServer4.1.1 创建NettyRemotingServer4.1.2 registerProcessor注册默认请求处理器4.1.3 启动定时任…
阅读更多...
Google C++ Style文档及常用代码规范（一）：命名约定、格式、注释

Google C++ Style文档及常用代码规范（一）：命名约定、格式、注释

文章目录 Google C Style文档及常用代码规范&#xff08;一&#xff09;&#xff1a;命名约定、格式、注释命名约定通用命名规则文件命名类型命名变量命名常量命名函数命名命名空间命名枚举命名宏命名命名规则的特例 格式注释注释风格文件注释类注释函数注释变量注释类数据成员…
阅读更多...
flutter getx nested navigation 嵌套路由

flutter getx nested navigation 嵌套路由

flutter getx nested navigation 嵌套路由 视频 https://youtu.be/SXER4JVBFps 前言 嵌套路由可以用在如购物确认向导界面切换。 使用 getx 实现嵌套路由&#xff0c;需要如下步骤&#xff1a; 通过 Navigator 组件的 key 属性 用 Get.nestedKey(1) 进行标记 onGenerateRoute…
阅读更多...
delmia msd学习

delmia msd学习

在默认打开的结构树中添加一个产品tworobts TwoRobots是新建的一个空产品&#xff0c;并将其插入到resoourceslist下面通过 然后创建一个工位的工作区域 插入机器人 把机器人放在工作区域中,即其子物体 先选要移动的对象&#xff0c;然后选移动到什么地方 Keep positions的意思…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023