codetop+acwing加减乘除法与位运算的总结，别再饶头啦！！！

___Dream

于 2024-09-17 12:04:52 发布

阅读量505

点赞数 11

分类专栏： # 秒杀系列：一文秒杀整个题型！文章标签：算法 c++ 数据结构高精度

本文链接：https://blog.csdn.net/weixin_45962681/article/details/142311863

版权

秒杀系列：一文秒杀整个题型！专栏收录该内容

8 篇文章 0 订阅

订阅专栏

加减乘除+位运算，涉及位运算的题目一般很简单

1.高精度加法
2.高精度减法
3.高精度乘法
4.高精度除法
5.字符串相加
6.字符串相乘
7.二进制中1的个数
8.位1的个数
9.二的幂

1.高精度加法

给定2个正整数(不含前导0)，计算它们的和。1<=整数长度<=100000

模拟567+28，倒序存储在两个数组AB中，A=[7,6,5]，B=[8,2]，因为这样从位序0开始计算更方便，还有个C保存结果，t保存进位，初始t=0，将各个位上的数字相加，求出结果对应位上的数字和进位。例如对个位计算： A[0] + B[0] = 7 + 8 = 15, 结果个位上是 5，进位是 1. 所以 C[0] = 5, 进位 t = 1

#include <iostream>
#include <vector>
using namespace std;
vector<int> add(vector<int> &A, vector<int> &B)
{
    //为了方便计算，让A中保存较长的数字， B中保存较短的数字
    if (A.size() < B.size()) return add(B, A);
    //保存结果的数组
    vector<int> C;
    //进位，开始时是0
    int t = 0;
    //依次计算每一位
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i];//加上 A 的第 i 位上的数字
        if (i < B.size()) t += B[i];//加上 B 的第 i 位上的数字
        C.push_back(t % 10); //C 中放入结果
        t /= 10;//t 更新成进位
    }
    //最后如果进位上有数，放进结果数组
    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 -- ) cout << C[i];//倒序输出C中的数字
    cout << endl;
    return 0;
}

2.高精度减法

给定两个正整数(不含前导0)，计算它们的差，计算结果可能为负数。1<=整数长度<=10^5

和高精度加法差不多，不同在于减法的借位处理；相减为负数的处理；前导0的处理
下面单拎函数解释，比较大小这部分放到main函数中会冗余，所以单独封装

单独函数：
比较大小，不多说

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

减法函数，注意1点

相减后 t 的处理，把 t >=0 和 t < 0 用一个式子来表示 t = (t + 10) % 10

为什么可以这样呢，因为做 A[i] - B[i]，得到一个暂时的 t ，如果 t 小于 0（即 A[i] < B[i]），需要向更高的一位借 1（相当于借 10），使得当前位的结果 t 不再是负数。借位后，我们需要将结果转换为 0-9 范围的一个数。
所以 t = (t + 10) % 10 相当于综合了 t 小于 0 和大于 0 的两种情况得到减后的数字。

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) % 10 ); // 合而为1
        if(t < 0)  t = 1;
        else t = 0;

    }
    while(C.size() > 1 && C.back() == 0) C.pop_back();  //去掉前导0
    return C;
}

综合代码：

// 给定两个正整数

#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();  //直接ruturn 了就不用else

    for(int i = A.size(); i >= 0; i--)
        if(A[i] != B[i])
            return A[i] > B[i];

    return true;
}

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) % 10 ); // 合而为1
        if(t < 0)  t = 1;
        else t = 0;

    }

    while(C.size() > 1 && C.back() == 0) C.pop_back();  //去掉前导0

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


}

3.高精度乘法

给定 2 个非负数(不含前导0) A 和 B ，计算A×B
1≤A的长度≤100000,0≤B≤10000

高精度×低精度：只需要逐位将高精度数与低精度数相乘，并处理简单的进位问题，计算较为简单。

vector <int> mul(vector <int> & A, int b) {
    vector <int> C;

    int t = 0;
    for (int i = 0; i < A.size(); i ++) {
        t += A[i] * b;       // t + A[i] * b = 7218
        C.push_back(t % 10); // 只取个位 8
        t /= 10;             // 721 看作 进位
    }

    while (t) {            // 处理最后剩余的 t
        C.push_back(t % 10);
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();

    return C;
}

重点！！
高精度×高精度：需要进行每一位的组合相乘，并将结果累加到相应的位上，计算更复杂，并且需要处理多次进位和累加操作，计算复杂度较高。

把mul函数再单拎逻辑来讲讲：

核心乘法逻辑->按位相乘，将 A[i] 和 B[j] 的乘积加到 C[i + j] 位置上。

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

处理进位->t 变量用于处理进位。在每一位中，先将之前累加的乘积加到 t 中，然后 C[i] = t % 10 只保留当前位的个位数，t /= 10 将进位的部分存入 t 以备加到下一位

int t = 0;
for(int i = 0; i < C.size(); i ++){
	t += C[i];
	C[i] = t % 10;
	t /= 10;
}

综合代码：

vector<int> mul(vector<int> &A, vector<int> &B) {
    vector<int> C(A.size() + B.size() + 10, 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;
}

4.高精度除法

给定两个非负整数（不含前导 0） A，B，请你计算 A/B 的商和余数。
输入：一行A一行B
输出：一行商一行余数

这里是高精度除低精度，高精度除高精度的不用学

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//int r=0;
vector<int> div(vector<int> &A,int B,int &r){//r传入r的地址，便于直接对余数r进行修改
    vector<int> C;
    for(int i = 0; i < A.size(); i ++){//对A从最高位开始处理
        r = r * 10 + A[i];//将上次的余数*10在加上当前位的数字，便是该位需要除的被除数
        C.push_back(r / B);//所得即为商在这一位的数字
        r = r % B;
    }
    //由于在除法运算中，高位到低位运算，因此C的前导零都在vector的前面而不是尾部，vector只有删除最后一个数字pop_back是常数复杂度，而对于删除第一位没有相应的库函数可以使用，而且删除第一位，其余位也要前移，
    //因此我们将C翻转，这样0就位于数组尾部，可以使用pop函数删除前导0
    reverse(C.begin(), C.end());
    while(C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}
int main(){
    string a;
    int B, r = 0; //代表余数
    cin >> a >> B;
    vector<int> A;
    for(int i = 0;i < a.size(); i ++) A.push_back(a[i] - '0');//注意这次的A是由高为传输至低位，由于在除法的手算过程中，发现从高位进行处理
    //for(int i=0;i<A.size();i++) cout<<A[i];
    //cout<<B;
    auto C = div(A, B, r);
    for(int i = C.size() - 1; i >= 0; i --) cout << C[i];//将C从最高位传给最低位
    cout << endl << r;//输出余数
    cout << endl;
    return 0;
}

5.字符串相加

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。

你不能使用任何內建的用于处理大整数的库（比如 BigInteger），也不能直接将输入的字符串转换为整数形式。

根据上面的高精度几道题，这里其实容易很多了

class Solution {
public:
    string addStrings(string num1, string num2) {
        string answer;
        int cur = 0;//用来记录每一位对应数字的相加和
        int len1 = num1.size()-1, len2 = num2.size()-1;//从字符串的最低位开始
        while(len1>=0 || len2>=0 || cur>0)
        {
            if(len1>=0) cur += num1[len1--] - '0';
            if(len2>=0) cur += num2[len2--] - '0';
            answer += to_string(cur%10);//现在是逆序相加的
            cur /= 10;//保留进位进入下次运算
        }
        reverse(answer.begin(),answer.end());
        return answer;
    }
};

6.字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

注意：不能使用任何内置的 BigInteger 库或直接将输入转换为整数。

完全用3的解法

class Solution {
public:
    vector<int> mul(vector<int> &A, vector<int> &B) {
        vector<int> C(A.size() + B.size() + 10, 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;
    }
    string multiply(string num1, string num2) {
        vector<int> A, B;
        for(int i = num1.size() - 1; i >= 0; i --) A.push_back(num1[i] - '0');
        for(int i = num2.size() - 1; i >= 0; i --) B.push_back(num2[i] - '0');
        auto C = mul(A, B);

        string res = "";
        for(int i = C.size()-1; i >= 0; i--) res += to_string(C[i]);
        return res;


    }
};

7.二进制中1的个数

给定一个长度为 n 的数列，请你求出数列中每个数的二进制表示中 1 的个数。

对于每个数字a，a&1就得到了该数组的最后一位，之后将a右移一位，直到0，就得到了1的个数

#include<iostream>
using namespace std;
int n;
int a,k;
int main(){
    scanf("%d", &n);
    for(int i = 0; i < n; i ++){
        scanf("%d", &a);
        k = 0;
        while(a){
            k += a & 1;
            a = a >> 1;
        }
        printf("%d ", k);
    }
    return 0;
}

8.位1的个数

和7是一样的

class Solution {
public:
    int hammingWeight(int n) {
        int k = 0;
        while(n){
            k += n & 1;
            n = n >> 1;
        }
        return k;
    }
};

9.二的幂

如果一个数 n 是 2 的幂次方，那么它的二进制中只有一个 1。

另外，n的范围是-2³¹ <= n <= 2³¹ - 1
所以n可以是负数，那么负数直接false

class Solution {
public:
    bool isPowerOfTwo(int n) {
        if(n < 0) return false;
        int k = 0;
        while(n){
            k += n & 1;
            n = n >> 1;
        }
        if(k == 1) return true;
        else return false;
    }
};