洛谷P1045 [NOIP 2003 普及组] 麦森数

原创已于 2025-09-27 20:42:53 修改 · 694 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数学 #高精度

于 2025-09-27 20:40:17 首次发布

c++ NOIP 编程题专栏收录该内容

22 篇文章

订阅专栏

题目描述

形如 2P−1 的素数称为麦森数，这时 P 一定也是个素数。但反过来不一定，即如果 P 是个素数，2P−1 不一定也是素数。到 1998 年底，人们已找到了 37 个麦森数。最大的一个是 P=3021377，它有 909526 位。麦森数有许多重要应用，它与完全数密切相关。

任务：输入 P(1000<P<3100000)，计算 2P−1 的位数和最后 500 位数字（用十进制高精度数表示）

输入格式

文件中只包含一个整数 P(1000<P<3100000)

输出格式

第一行：十进制高精度数 2P−1 的位数。

第 2∼11 行：十进制高精度数 2P−1 的最后 500 位数字。（每行输出 50 位，共输出 10 行，不足 500 位时高位补 0）

不必验证 2P−1 与 P 是否为素数。

输入输出样例

输入 #1复制

输出 #1复制

386
00000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000
00000000000000104079321946643990819252403273640855
38615262247266704805319112350403608059673360298012
23944173232418484242161395428100779138356624832346
49081399066056773207629241295093892203457731833496
61583550472959420547689811211693677147548478866962
50138443826029173234888531116082853841658502825560
46662248318909188018470682222031405210266984354887
32958028878050869736186900714720710555703168729087

说明/提示

【题目来源】

NOIP 2003 普及组第四题

题目分析

麦森数是指形如 2^p - 1 的数，其中 p 是一个素数。本题要求计算 2^p - 1 的位数以及最后500位数字（不足500位时前面补0）。

难点分析

大数计算：当 p 很大时（题目中 p 最大为3100000），2^p 的值极其巨大，无法用常规数据类型存储。
高效计算：直接进行 p 次乘法会超时，需要使用快速幂算法。
位数计算：不需要实际计算整个数就能确定位数。
存储优化：只需存储最后500位，可以节省空间。

数学原理

位数计算

对于 2^p - 1 的位数，我们可以利用对数性质：

设 N = 2^p - 1，由于 2^p 远大于1，所以 N ≈ 2^p。

根据对数性质：log10(2^p) = p · log10(2)

数的位数 d = floor(log10(N)) + 1 ≈ floor(p · log10(2)) + 1

快速幂算法

快速幂算法通过二分思想将时间复杂度从 O(p) 降低到 O(log p)：

当 p 为偶数时：a^p = (a^(p/2))^2
当 p 为奇数时：a^p = a · (a^((p-1)/2))^2

算法设计

数据结构

使用整型数组存储大数，每个元素存储若干位数字（这里选择每元素存储1位数字，便于理解）。

核心算法

计算位数：直接使用公式 d = floor(p · log10(2)) + 1
计算最后500位：使用快速幂算法，只保留最后500位
减法处理：计算 2^p - 1，注意借位问题

代码实现

cpp

代码详细解析

头文件说明

cpp

#include <iostream>
#include <cmath>
#include <cstring>
using namespace std;

// 大数乘法（只保留最后500位）
// a: 第一个大数数组（每位存储一个数字）
// b: 第二个大数数组（每位存储一个数字）
void mul(int a[], int b[]) {
    int tmp[1005] = {0}; // 临时结果数组，初始化为0
    
    // 模拟竖式乘法，计算每一位的乘积
    for (int i = 0; i < 500; i++) {
        for (int j = 0; j < 500; j++) {
            if (i + j < 1000) { // 只计算可能影响最后500位的部分
                tmp[i + j] += a[i] * b[j];
            }
        }
    }
    
    // 处理进位，只保留最后500位
    for (int i = 0; i < 500; i++) {
        if (i < 999) {
            tmp[i + 1] += tmp[i] / 10; // 进位到高位
        }
        tmp[i] %= 10; // 保留个位数
    }
    
    // 将结果复制回a数组（只取最后500位）
    for (int i = 0; i < 500; i++) {
        a[i] = tmp[i];
    }
}

// 快速幂计算 2^p
// p: 指数
void qpow(int p) {
    int res[1005] = {0}; // 结果数组，存储最终结果
    int base[1005] = {0}; // 底数数组，存储当前底数
    
    // 初始化：res = 1, base = 2
    res[0] = 1;  // 个位为1
    base[0] = 2; // 个位为2
    
    // 快速幂算法核心
    while (p > 0) {
        if (p % 2 == 1) {
            mul(res, base); // 如果指数是奇数，结果乘以当前底数
        }
        mul(base, base); // 底数平方
        p /= 2; // 指数减半
    }
    
    // 执行减法：2^p - 1
    res[0] -= 1; // 个位减1
    // 处理借位
    for (int i = 0; i < 500; i++) {
        if (res[i] < 0) {
            res[i] += 10; // 借位
            res[i + 1] -= 1;
        }
    }
    
    // 输出最后500位，每50位换行
    for (int i = 499; i >= 0; i--) {
        cout << res[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;
    
    // 计算并输出最后500位
    qpow(p);
    
    return 0;
}

大数乘法函数 mul

这是整个程序的核心函数，负责处理大数乘法运算：

cpp

void mul(int a[], int b[]) {
    int tmp[1005] = {0}; // 临时数组，大小1005确保有足够空间

临时数组 tmp 用于存储乘法运算的中间结果。我们分配1005个元素是为了确保有足够的空间处理进位，即使两个500位的数相乘也不会溢出。

cpp

    for (int i = 0; i < 500; i++) {
        for (int j = 0; j < 500; j++) {
            if (i + j < 1000) {
                tmp[i + j] += a[i] * b[j];
            }
        }
    }

这部分代码模拟手工竖式乘法。外层循环遍历第一个数的每一位，内层循环遍历第二个数的每一位。a[i] * b[j] 的结果应该放在 tmp[i+j] 位置，因为这是相应位的乘积。

条件 i+j < 1000 是一个优化，只计算可能影响最后500位的乘积，因为更高位的结果最终会被舍弃。

cpp

    for (int i = 0; i < 500; i++) {
        if (i < 999) {
            tmp[i + 1] += tmp[i] / 10;
        }
        tmp[i] %= 10;
    }

这部分处理进位。对于每一位，如果值大于等于10，就将十位部分加到下一位，只保留个位在当前位。

cpp

    for (int i = 0; i < 500; i++) {
        a[i] = tmp[i];
    }
}

最后将临时数组的前500位复制回原数组，完成乘法运算。

快速幂函数 qpow

这个函数使用快速幂算法高效计算 2^p：

cpp

void qpow(int p) {
    int res[1005] = {0}; // 结果数组
    int base[1005] = {0}; // 底数数组

res 数组存储最终结果，初始化为1（2^0 = 1）。base 数组存储当前底数，初始化为2。

cpp

    res[0] = 1;
    base[0] = 2;

初始化结果和底数。使用数组的0索引表示个位，这是大数存储的常见方式。

cpp

    while (p > 0) {
        if (p % 2 == 1) {
            mul(res, base);
        }
        mul(base, base);
        p /= 2;
    }

这是快速幂算法的核心循环：

如果当前指数p是奇数，将结果乘以当前底数
无论指数奇偶，底数都要平方
指数除以2（向下取整）

通过这种方式，算法复杂度从O(p)降低到O(log p)。

cpp

    res[0] -= 1;
    for (int i = 0; i < 500; i++) {
        if (res[i] < 0) {
            res[i] += 10;
            res[i + 1] -= 1;
        }
    }

计算 2^p - 1，从个位开始减1，并处理可能的借位。

cpp

    for (int i = 499; i >= 0; i--) {
        cout << res[i];
        if (i % 50 == 0 && i != 0) {
            cout << endl;
        }
    }
}

逆序输出结果数组（因为数组是低位在前），每50位换行，满足题目输出格式要求。

主函数 main

cpp

int main() {
    int p;
    cin >> p;
    
    int digits = (int)(p * log10(2)) + 1;
    cout << digits << endl;
    
    qpow(p);
    
    return 0;
}

主函数逻辑清晰：