P1045麦森数

题目

这是一道聚集了高精度减法、乘法，还有快速幂算法还有一点数学公式

先放出完整的代码

#include <iostream>
#include <cmath>
#include <cstring>
using namespace std;
const int MAX_DIGITS = 500; 
void multiply(int a[], int b[]) {
    int temp[MAX_DIGITS * 2] = {0}; 
    for (int i = 0; i < MAX_DIGITS; i++) {
        for (int j = 0; j < MAX_DIGITS; j++) {
            temp[i + j] += a[i] * b[j];
        }
    }
    int carry = 0;
    for (int i = 0; i < MAX_DIGITS; i++) {
        temp[i] += carry;
        a[i] = temp[i] % 10;
        carry = temp[i] / 10;
    }
}
void fastPower(int result[], int P) {
    int base[MAX_DIGITS] = {0};
    base[0] = 2; 
    result[0] = 1; 

    while (P > 0) {
        if (P & 1) { 
            multiply(result, base); 
        }
        multiply(base, base); 
        P >>= 1; 
    }
}
void subtractOne(int a[]) {
    int i = 0;
    while (a[i] == 0) {
        a[i] = 9;
        i++;
    }
    a[i]--;
}

void printLast500Digits(int a[]) {
    for (int i = MAX_DIGITS - 1; i >= 0; i--) {
        cout << a[i];
        if (i % 50 == 0 && i != 0) cout << endl; 
    }
}

int main() {
    int P;
    cin >> P;
    int digits = (int)(P * log10(2)) + 1;
    cout << digits << endl;
    int num[MAX_DIGITS] = {0};
    fastPower(num, P);
    subtractOne(num); 
    printLast500Digits(num);
    return 0;
}

ok现在会一个函数一个函数来解释一下

首先是高精度算法这个函数

void multiply(int a[], int b[]) {
    int temp[MAX_DIGITS * 2] = {0}; 
    for (int i = 0; i < MAX_DIGITS; i++) {
        for (int j = 0; j < MAX_DIGITS; j++) {
            temp[i + j] += a[i] * b[j];
        }
    }
    int carry = 0;
    for (int i = 0; i < MAX_DIGITS; i++) {
        temp[i] += carry;
        a[i] = temp[i] % 10;
        carry = temp[i] / 10;
    }
}

        在计算机中，普通的数据类型（如 int、long long）能存储的数字范围是有限的。例如，int 通常只能存储大约 10 位数字。如果想计算像 2^1000 这样的非常大的数，普通的数据类型就无法存储了。使用高精度算法就可以解决这个问题，可以使用 高精度计算，即用数组来存储大数的每一位。例如，数字 12345 可以用数组 [5, 4, 3, 2, 1] 表示（注意：数组的低位存储数字的低位，这样方便计算（这样是可以理解为从数组0开始是已知的比较方便）。

ok高精度算法（这里是乘法）

void multiply(int a[], int b[]) {
    int temp[MAX_DIGITS * 2] = {0}; 
    for (int i = 0; i < MAX_DIGITS; i++) {
        for (int j = 0; j < MAX_DIGITS; j++) {
            temp[i + j] += a[i] * b[j];
        }
    }
    int carry = 0;
    for (int i = 0; i < MAX_DIGITS; i++) {
        temp[i] += carry;
        a[i] = temp[i] % 10;
        carry = temp[i] / 10;
    }
}

        要进行乘法运算的两个数组是a和b，temp数组的大小在这里是按照题意开出的大小，如果是实际运用数组的大小要开到a数组的大小加上b数组的大小还要多开几个大小，因为可能会有进位。

        然后这里前面一个双重for循环是模拟手算乘法的过程

        逐位相乘：遍历a和b的每一位，将乘积累加到temp数组的对应位置，这只是一个临时的数组，比如说123*32手算是123*2然后123*3左移一位相加。那么temp[i]的位置就是存储的相应的数字

然后后面一个for循环是来处理进位的问题。

这个是使用vector数组来处理高精度问题

vector<int> mul(const vector<int>& A, const vector<int>& B) {
    vector<int> C(A.size() + B.size(), 0); 
    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++) {
        C[i] += t; 
        t = C[i] / 10; 
        C[i] %= 10; 
    }
    while (C.size() > 1 && C.back() == 0) {
        C.pop_back();
    }
    return C;
}

高精度减法

void subtractOne(int a[]) {
    int i = 0;
    while (a[i] == 0) {
        a[i] = 9;
        i++;
    }
    a[i]--;
}

这里还是符合提议的高精度，因为数组存储是数组低位存储数据低位，再由减法的特性不够减的话要向前借一，那么这里代码的意思是从个位数开始找如果为0就向前一位借以，如果前一位为0还要向前借一位，一直进行这个操作直至这个位置不为0。为0的话借一位就为9.....

然后写一个平常的高精度减法

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

现在是高速幂

代码

void fastPower(int result[], int P) {
    int base[MAX_DIGITS] = {0};
    base[0] = 2; 
    result[0] = 1; 

    while (P > 0) {
        if (P & 1) { 
            multiply(result, base); 
        }
        multiply(base, base); 
        P >>= 1; 
    }
}

高速幂

快速幂算法（也称为 二分幂算法 或 平方求幂算法）是一种高效计算大数幂次的算法。它的核心思想是通过 二进制分解 和 逐步平方 来减少乘法的次数，从而将时间复杂度从 O(n) 降低到 O(log n)。

逻辑

将指数分解为二进制形式

result初始化为1因为base^0为1，base是当前的基数，初始为输入的底数

循环处理

        首先检查指数的最低二进制位：如果最低位为1则将base乘入result

        将base自乘（base=base*base），表示基数翻倍。

        将指数右移一位（即去掉最低位）

结束条件：当指数位0的时候，循环结束，resul中存储的就是最终结果。

这个过程好好理解一下，很好理解

快速幂一般方法

long long fastPower(long long base, long long exponent) {
    long long result = 1; 
    while (exponent > 0) {
        if (exponent & 1) { 
            result *= base; 
        }
        base *= base; 
        exponent >>= 1; 
    }
    return result;
}

这道题到这里就结束啦，收看愉快！（wink~)