分治 麦森数解题报告（转）

最新推荐文章于 2023-07-30 13:35:37 发布
最新推荐文章于 2023-07-30 13:35:37 发布
阅读量966 收藏
点赞数
分类专栏： NOIP相关

描述 Description        

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

任务：从文件中输入P（1000<P<3100000），计算2^P-1的位数和最后500位数字（用十进制高精度数表示）

输入格式 Input Format      

      文件中只包含一个整数P（1000<P<3100000）

输出格式 Output Format    

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

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

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

样例输入 Sample Input      

1279

样例输出 Sample Output    

386

00000000000000000000000000000000000000000000000000

00000000000000000000000000000000000000000000000000

00000000000000104079321946643990819252403273640855

38615262247266704805319112350403608059673360298012

23944173232418484242161395428100779138356624832346

49081399066056773207629241295093892203457731833496

61583550472959420547689811211693677147548478866962

50138443826029173234888531116082853841658502825560

46662248318909188018470682222031405210266984354887

32958028878050869736186900714720710555703168729087

 

题目分析：

第一问是很简单的，只需要求一个对数而已，数学原理：十进制正整数n的位数为int(log10(n))+1。所以2^P-1的位数int(log10(2)*p)+1 。

第二问的关键是高精度乘法和指数幂的运算，而且由于题目要求最后500位数字，所以在计算乘法的时候我们只要求计算乘数的低500位就好了。

指数幂的运算不能硬乘，而要采用分治算法，否则就超时了。分治递归算法求指数幂是非常经典的，其数学原理是a^n = a^(n/2)*a^(n/2)*f(a)，其中f(a) = 1(n%2==0)或f(a) = a(n%2==1)。

另外我们也可以创建一个栈，记录每次执行(n /= 2)前n的值是奇数还是偶数，然后根据上面的数学原理，模仿递归的思路，从n=1或n=0开始逆向计算a^n。

采用递归算法的时候，由于存储高精度整数数组的大小是预置MAX = 1000，所以在调用递归函数的时候要按引用传递参数，否则到了后面空间就不够分配了。

为了满足“每行输出50位”的条件，我把存储高精度整数数组的元素设置成5位数，这样输出的时候只需每行输出10个元素就行了。

 

说明：

算法思想：递归分治和高精度。

数据结构：结构数组。

时间复杂度：O(LEN*LEN*lonN)，其中LEN = 500 / WIDTH + 1;

空间复杂度：O(MAX);

程序语言：分别用c++和pascal实现。

附注：分别提供了递归和非递归算法求指数幂的子函数。

关于高精度整数的四则运算请参考拙作《高精度整数运算改进版》：

http://blog.csdn.net/goal00001111/archive/2008/12/15/3522737.aspx


//PASCAL代码：

PROGRAM EXAMBigInt(INPUT, OUTPUT);
CONST
    MAX = 1000; {整型数组的最大长度}
    WIDTHMAX = 100000; {整型数组val[MAX]的元素上限}
    WIDTH = 5; {输出整型数组val[MAX]的元素时的格式宽度，为方便输出，设成500的因数}
    MAXLENGTH = 500; {输出数字的位数}
type
    BigInt = RECORD
        val  : array [1..MAX] of int64; {用来存储高精度整数}
        size : LongWord;  {整型数组的实际长度}
    end;
VAR
    a, b : BigInt;
    p : LongWord;

PROCEDURE PrintBigInt(a : BigInt);
    var
        i : LongWord;
    begin
        while (a.size*WIDTH) < MAXLENGTH do {少则补足0}
        begin
            inc(a.size);
            a.val[a.size] := 0;
        end; {while}
        while (a.size*WIDTH) > MAXLENGTH do {多则只取低500}
            dec(a.size);
        for i:=a.size downto 1 do
        begin
            if a.val[i] < 10 then
                write('0000')
            else if a.val[i] < 100 then
                write('000')
            else if a.val[i] < 1000 then
                write('00')
            else if a.val[i] < 10000 then
                write('0');
            write(a.val[i]);
            if (i mod 10) = 1 then
                writeln;
        end; {for}
     end; {PrintBigInt}
 
FUNCTION MulBigInt(a, b : BigInt): BigInt;
    const
        LEN = MAXLENGTH div WIDTH;
    var
        c : BigInt;
        i, j : LongWord;
    begin
        if (a.size = 1) and (a.val[1] = 0) then
            MulBigInt := a
        else if (b.size = 1) and (b.val[1] = 0) then
            MulBigInt := b
        else
        begin
            for i:=1 to MAX do {全部赋初值为0}
                c.val[i] := 0;
            i := 1;
            while (i <= b.size) and (i <= LEN) do
            begin
                j := 1;
                while (j <= a.size) and (j <= LEN) do
                begin
                    c.val[i+j-1] := c.val[i+j-1] + a.val[j] * b.val[i];
                    c.val[i+j] := c.val[i+j] + c.val[i+j-1] div WIDTHMAX;
                    c.val[i+j-1] := c.val[i+j-1] mod WIDTHMAX;
                    inc(j);
                end; {while}
                c.size := i + j - 1;
                if c.val[c.size] <> 0 then {最高位有进位}
                    inc(c.size);
                inc(i);
            end; {while}
            MulBigInt := c;
        end; {else}
    end; {MulBigInt}

PROCEDURE PowBigInt(var c : BigInt; n : LongWord);
    begin
        if (n = 0) or (n = 1) then {指数为0，则幂等于1；指数为1，则幂等于底数2}
        begin
            c.size := 1;
            c.val[1] := n + 1;
            exit;
        end; {if}
        PowBigInt(c, n div 2); {递归求高精度整数幂}
        c := MulBigInt(c, c); {a^n = a^(n/2)*a^(n/2)*f(a)}
        if (n mod 2) = 1 then {其中f(a) = 1(n%2==0)或f(a) = a(n%2==1)}
            c := MulBigInt(b, c);
    end; {PowBigInt}

{
PROCEDURE PowBigInt(var c : BigInt; n : LongWord);
    var
        stack : array[1..MAX] of integer;
        i, top : LongWord;
    begin
        top := 0;
        while n > 0 do
        begin
            inc(top);
            stack[top] := n mod 2;
            n := n div 2;
        end; {while}
        c.size := 1;
        c.val[1] := 1;
        for i:=top downto 1 do
        begin
            c := MulBigInt(c, c);
            if stack[i] = 1 then
                c := MulBigInt(c, b);
        end; {for}
    end; {PowBigInt}
}

BEGIN
    read(p);
    writeln(trunc(p * ln(2) / ln(10)) + 1); {输出十进制高精度数2^P-1的位数}
    b.size := 1;
    b.val[1] := 2;
    PowBigInt(a, p);
    dec(a.val[1]);
    PrintBigInt(a);
    writeln;
END.




//c++代码：

#include<iostream>

#include<math.h>

 

using namespace std;

 

const unsigned int MAX = 1000; //整型数组的最大长度

const long long WIDTHMAX = 100000;//整型数组val[MAX]的元素上限

const unsigned int WIDTH = 5; //输出整型数组val[MAX]的元素时的格式宽度，为方便输出，设成500的因数

 

typedef struct node

{

    long long val[MAX];//用来存储高精度整数

    unsigned int size; //整型数组的实际长度

} BigInt;

 

void PrintBigInt(BigInt a);

BigInt MulBigInt(const BigInt & a, const BigInt & b);

void PowBigInt(BigInt & c, unsigned int n);

 

int main()

{

    unsigned int p;

    cin >> p;

   

    cout << int(log10(2)*p) + 1 << endl;  //输出十进制高精度数2^P-1的位数

   

    BigInt a;

    PowBigInt(a, p);

    a.val[0] -= 1;

    PrintBigInt(a);

   

    system("pause");

       return 0;

}

/*

函数名称：PowBigInt

函数功能：递归高效算法求高精度整数幂，底数默认为2

输入参数：BigInt & c：存储高精度整数幂的整型数组

          unsigned int n：  指数

输出参数：BigInt & c：存储高精度整数幂的整型数组 

*/

void PowBigInt(BigInt & c, unsigned int n)

{

    if (n == 0 || n == 1)//指数为0，则幂等于1；指数为1，则幂等于底数2

    {

        c.size = 1;

        c.val[0] = n + 1;

        return ; 

    }

   

    PowBigInt(c, n/2); //递归求高精度整数幂

   

    c = MulBigInt(c, c); //a^n = a^(n/2)*a^(n/2)*f(a)

    if (n % 2 == 1)     //其中f(a) = 1(n%2==0)或f(a) = a(n%2==1)

    {

        BigInt b;

        b.size = 1;

        b.val[0] = 2; //底数默认为2

        c = MulBigInt(b, c);

    }

}

/**/

 

/*

函数名称：PowBigInt

函数功能：非递归高效算法求高精度整数幂，底数默认为2

输入参数：BigInt & c：存储高精度整数幂的整型数组

          unsigned int n：  指数

输出参数：BigInt & c：存储高精度整数幂的整型数组 

*

void PowBigInt(BigInt & c, unsigned int n)

{

    int stack[MAX] = {0};

    int top = 0;

    while (n > 0) //利用一个栈来存储n的状态：奇数还是偶数

    {

        stack[top++] = n % 2;

        n /= 2;

    }

    BigInt b;

    b.size = 1;

    b.val[0] = 2; //底数默认为2

    c.size = 1;

    c.val[0] = 1;

    for (int i=top-1; i>=0; i--)

    {

        c = MulBigInt(c, c);  //a^n = a^(n/2)*a^(n/2)*f(a)

        if (stack[i] == 1)   //其中f(a) = 1(n%2==0)或f(a) = a(n%2==1)

            c = MulBigInt(b, c);

    }

}

/**/

/*

函数名称：PrintBigInt

函数功能：十进制高精度数2^P-1的最后500位数字，每行输出50位，共输出10行，不足500位时高位补0

输入参数：BigInt a：存储高精度整数幂的整型数组

输出参数：无

*/

void PrintBigInt(BigInt a)

{

    while (a.size*WIDTH < 500)//少则补足0

    {

        a.val[a.size++] = 0;

    }

    while (a.size*WIDTH > 500)//多则只取低500

    {

        a.size--;

    }

    for (int i=a.size-1; i>=0; i--)

    {

        if (a.val[i] < 10)

            cout << "0000";

        else if (a.val[i] < 100)

            cout << "000"; 

        else if (a.val[i] < 1000)

            cout << "00"; 

        else if (a.val[i] < 10000)

            cout << "0";      

        cout << a.val[i];

        if (i % 10 == 0) //每行输出10个元素

            cout << endl;

    }

}

/*

函数名称：MulBigInt

函数功能：高精度整数乘法

输入参数：const BigInt & a：用整型数组表示的高精度整数被乘数

          const BigInt & b：用整型数组表示的高精度整数乘数

输出参数：BigInt：返回用整型数组表示的高精度整数乘积

*/

BigInt MulBigInt(const BigInt & a, const BigInt & b)

{

    if (a.size == 1 && a.val[0] == 0)

        return a;

    if (b.size == 1 && b.val[0] == 0)

        return b;

   

    const int LEN = 500 / WIDTH + 1;//只需取低500位相乘就好了

    BigInt c;

    for (int i=0; i<MAX; i++) //全部赋初值为0

        c.val[i] = 0;

    for (int i=0, j=0; i<b.size && i<LEN; i++)

    {

        for (j=0; j<a.size && j<LEN; j++)

        {

            c.val[i+j] += a.val[j] * b.val[i];

            c.val[i+j+1] += c.val[i+j] / WIDTHMAX;

            c.val[i+j] %= WIDTHMAX;

        }

        c.size = i + j;

        if (c.val[c.size] != 0)//最高位有进位

            c.size++;

    }

    return c;

}


jvs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数字旋转方阵 分治法——C++代码
06-08
课程的随堂作业，C语言的，用dev就能运行，萌新代码，勿喷，仅仅帮助不想写作业的朋友方便一下，反正老师也不会仔细检查的
麦森数 —— 高精度乘法 与 快速幂综合应用
重燃2020！！！
07-28 632
麦森数 —— 高精度乘法 与 快速幂综合应用题目描述题目链接题解1，位数解法位数举一反三2，500位数的计算结语 题目描述 形如2^ P-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数，2^P-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数密切相关。 任务：从文件中输入P（1000<P<3100000），计算2^P-1的位数和最后500位数字（用十进制高精度数表示） 输
【C++题解】【NOIP2003PJ】麦森数
JG_DF_的博客
08-04 918
题目链接 题目描述 输入 文件中只包含一个整数P（1000<P<3100000） 输出 更新：此题输出两行 1. 第一行输出位数 2. 第二行输出结果的最后五百位 样例输入 1279 样例输出 386 00000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000 00000000000000104079321946643990819252403
vijos - P1223麦森数 (高精度乘法 + 分治 + python)
qq_18661257的专栏
08-15 1867
P1223麦森数 Accepted 标签：NOIP普及组2003[显示标签] 描述 形如2^P-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数，2^P-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数
P1045 [NOIP2003 普及组] 麦森数
dacongming123355的博客
04-26 509
与 有着相同的位数，因为2的次方满足了最后一位不为零的要求，所以减一后位数并不会改变，那么我们可以直接求 的位数。这个绝对难不倒大家，裸的高精快速幂，经过NOIP2017初赛的RP++后，相信很多人都已经会了快速幂了，所以我在这里不再赘述，只是提供一种相对较为简便的高精乘法（见程序）任务：输入 �(1000
NOIP2003 普及组 [麦森数] C++
最新发布
YaeSaraki's Blog
07-30 225
到 1998 年底，人们已找到了 37 个麦森数。，它有 909526 位。麦森数有许多重要应用，它与完全数密切相关。但反过来不一定，即如果。位数字（用十进制高精度数表示）NOIP 2003 普及组第四题。的素数称为麦森数，这时。第一行：十进制高精度数。文件中只包含一个整数。
digui.rar_分治法中位数
09-24
在分治法中寻找中位数，主要思路是通过不断地分割数组，缩小中位数可能存在的范围，直至找到确切的值。 在C++环境下，我们可以创建一个名为`digui.cpp`的源文件，实现这个功能。首先，我们需要一个函数来计算一个...
分治法求数组中的逆序数
03-12
有一实数序列a1,a2,....an，若i且ai>aj，则（ai，aj）形成了一个逆序对，请使用分治算法求整个序列中逆序对个数，并分析算法时间复杂度。
递归与分治算法解题报告.ppt
05-27
递归与分治算法解题报告.ppt
合并排序（分治策略）报告.doc
12-26
【合并排序（分治策略）】是一种高效的排序算法，它采用了经典的分治思想。分治法的基本策略是将一个难以直接解决的大问题分解为若干个规模较小、相互独立、与原问题形式相同的子问题，再将子问题的解组合得到原问题...
高精度计算问题（大数加法、乘法、麦森数）
05-07
高精度计算问题（大数加法、乘法、麦森数） 分析加代码
noip 2003普及组
10-25
noip 2003 普及组 带数据包 题一、乒乓球（Table.pas）题二、数字游戏（Game.pas）题三、栈（Stack.pas）题四、麦森数（Mason.pas）
C++ Mason数(麦森数)
ChanJose的博客
01-23 2213
一、题目        二、思路      1.考虑需要解决的问题：        （1）求出2^p-1的位数；        （2）求出2^p-1的最后500位；        （不用判断2的p次方减1和p是否是素数）      2.先解决第一个问题：求出2^p-1的位数         N = 10  -&gt; 位数为2；         N = 100 -&gt; 位数...
洛谷P1045题解
m0_57317650的博客
05-13 400
形如2P−1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数，2P−1不一定也是素数。到 1998 年底，人们已找到了 37 个麦森数。最大的一个是P3021377，它有 909526 位。麦森数有许多重要应用，它与完全数密切相关。任务：输入P1000P3100000，计算2P−1的位数和最后500位数字（用十进制高精度数表示）
1127.麦森数
SSL_bin的博客
05-12 190
形如 2^p−1 的素数称为麦森数，这时 p一定也是个素数。但反过来不一定，即如果 p 是个素数，2^p−1不一定也是素数。第2-11行：十进制高精度数 2^p−1的最后500位数字。任务：输入p，计算 2^p−1的位数和最后500位数字（用十进制高精度数表示）简单，用一个数在p为奇数时乘一个2，同时乘上记录((2^2)^2)……分析：2^p的末位>=2，所以2^p-1的位数与2^p相等。则2^p=(2^2)^p/2=((2^2)^2)^p/2/2。用另一个数在p不等于0时乘自己（2^2）^2……
洛谷：麦森数（P1045）C++
weixin_73060900的博客
02-11 730
洛谷麦森数c++详解版
P1045 麦森数(C++_高精度_快速幂)
ccql's Blog
01-31 1035
题目描述 形如2P-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数，2P-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数密切相关。 任务：从文件中输入P（1000<P<3100000），计算2P-1的位数和最后500位数字（用十进制高精度数表示） 输入格式 文件...
【洛谷 1045 && 蓝桥杯 算法训练 ALGO - 26】麦森数（二分 + 高精度）
Lili Liang的博客
04-02 565
目录1 题目问题描述输入格式输出格式样例输入样例输出2 题目分析3 题解 1 题目 问题描述 形如 2P−12 ^ {P}-12P−1 的素数称为麦森数，这时 PPP 一定也是个素数。但反过来不一定，即如果 PPP 是个素数， 2P−12 ^ {P}-12P−1 不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是 P=3021377P=3021377P=3021377 ，它有...
分治算法实验报告
06-02
分治算法是一种把问题分成多个子问题，然后将子问题的解合并起来得到原问题解的算法。通常情况下，分治算法可以分为三个步骤：分解、解决和合并。在本次实验中，我们将使用分治算法来解决一个经典的问题：求解一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值