【题解】[P1045] 麦森数

标签：题目   mes   个数   int   精度   表示   cheng   eof   cin   

题目

题目描述

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

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

输入格式

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

输出格式

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

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

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

输入输出样例

输入 #1

1279

输出 #1

386
00000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000
00000000000000104079321946643990819252403273640855
38615262247266704805319112350403608059673360298012
23944173232418484242161395428100779138356624832346
49081399066056773207629241295093892203457731833496
61583550472959420547689811211693677147548478866962
50138443826029173234888531116082853841658502825560
46662248318909188018470682222031405210266984354887
32958028878050869736186900714720710555703168729087

分析

首先，肯定要用高精。

分析时间：

直接模拟的话，3100000 是 310^6,也就是要成310^6次2。

而麦森数位数为909526，是10^6级别。

所以用高精度每乘一次2，要运算10^6次（高精乘低精，时间复杂度为线性），

乘310^6次2，就要运算310^12次，肯定要超时。

考虑用快速幂。

快速幂，是将310^6次乘2优化到log级别，也就是log2(310^6)大约是22。但是这样就要增加一个高精数组b[]来存2的幂，更新b[]数组也需要大量的时间。

这是更新b[]的代码

void get_cheng_b(){//函数的作用是将b[]平方
    int h[len2+len2+1], x;
    memset(h, 0, sizeof(h));
    F(i,1,len2){
        F(j,1,len2){
            h[i+j-1] += b[i]*b[j];
            x = h[i+j-1]/10;
            h[i+j-1] %= 10;
            int k = i+j;
            while(x){
                h[k] += x%10;
                x /= 10;
                x += h[k]/10;
                h[k] %= 10;
                k++; 
            }
        }
    }
    if(h[len2+len2])    len2 = len2+len2;
    else    len2 = len2+len2-1;
    F(i,1,len2){
        b[i] = h[i];
    }
}

求2^P的函数：

void get_cheng_ch(){//多位乘多位 
    int h[len + len2 + 1];
    memset(h, 0, sizeof(h)); 
    int x=0;
    F(i,1,len){
        F(j,1,len2){
            h[i+j-1]+=ch[i]*b[j];
            x=h[i+j-1]/10;
            h[i+j-1]%=10;
            int k = i+j;
            while(x){
                h[k] += x%10;
                x/=10;
                x += h[k]/10;
                h[k] %= 10;
                k++;
            }
        }
    }
    if(h[len+len2]){
        len = len+len2;
    }
    else
        len = len+len2-1;
    F(i,1,len){
        ch[i] = h[i];
    }
}
void get_cheng_b(){
    int h[len2+len2+1], x;
    memset(h, 0, sizeof(h));
    F(i,1,len2){
        F(j,1,len2){
            h[i+j-1] += b[i]*b[j];
            x = h[i+j-1]/10;
            h[i+j-1] %= 10;
            int k = i+j;
            while(x){
                h[k] += x%10;
                x /= 10;
                x += h[k]/10;
                h[k] %= 10;
                k++; 
            }
        }
    }
    if(h[len2+len2])    len2 = len2+len2;
    else    len2 = len2+len2-1;
    F(i,1,len2){
        b[i] = h[i];
    }
}
void get_jian(){
    int i=1;
    while(ch[i]==0){
        ch[i] = 9;
        i++;
    }   
    ch[i]--;
    if(ch[len] == 0 && i==len)  len--;
}
void get_mi(){
    b[1]=2;
    ch[1]=1;
    while(p){
        if(p%2){
            get_cheng_ch();//ch[]乘b[] 
        }   
        get_cheng_b();//b[]平方 
        p/=2;
    }
    get_jian();
}

2的幂，最大更新到2^P(比如P=64时，2^64=2^64),

也就是说，b[]的长度最大是2^（3*10^6），不也还是10^6吗？

每调用一次get_cheng_b()函数，就要运行（10^6）^2次（高精乘高精，时间复杂度是平方级别），

而while循环22次每次调用一个get_cheng_b()和一个get_cheng_ch(）,一共要运算22*[(10^6）^2+10^6]次，时间是无法接受的。

咋办？

但是仔细读题，发现题目只让求后500位。也就是说b[]和ch[]只用寸500位的数据

所以时间问题迎刃而解(其实仔细想想问题的含义就不会有时间问题了)。

位数怎么搞？

是2^P-1的位数，与2^P的位数一样。
注意到10^m的位数是m+1。
我们将2^P转化为以10为底，这样次数加一就是位数。
设次数为x，10^x=2^P,
x=log10（2^P）=[log10(2)]*P
输出x+1即可。

还有两个问题：

1.减一的退位问题

发现2的幂末位不可能为0，所以不考虑退位，jian()函数可以去掉。

2.前导零问题

像我这样直接开一个500位的数组，全部初始为0，如果总位数小于500，那前面的0是没动的，直接输出数组元素，不用考虑前导零。

代码改后是这样：

void get_cheng_ch(){//多位乘多位 
    int h[len + len2 + 1];
    memset(h, 0, sizeof(h)); 
    int x=0;
    F(i,1,len){
        F(j,1,len2){
            h[i+j-1]+=ch[i]*b[j];
            x=h[i+j-1]/10;
            h[i+j-1]%=10;
            int k = i+j;
            while(x){
                h[k] += x%10;
                x/=10;
                x += h[k]/10;
                h[k] %= 10;
                k++;
            }
        }
    }
    if(h[len+len2]){
        len = min(510,len+len2);
    }
    else
        len = min(510,len+len2-1);
    F(i,1,len){
        ch[i] = h[i];
    }
}
void get_cheng_b(){
    int h[len2+len2+1], x;
    memset(h, 0, sizeof(h));
    F(i,1,len2){
        F(j,1,len2){
            h[i+j-1] += b[i]*b[j];
            x = h[i+j-1]/10;
            h[i+j-1] %= 10;
            int k = i+j;
            while(x){
                h[k] += x%10;
                x /= 10;
                x += h[k]/10;
                h[k] %= 10;
                k++; 
            }
        }
    }
    if(h[len2+len2])    len2 = min(510,len2+len2);
    else    len2 = min(510,len2+len2-1);
    F(i,1,len2){
        b[i] = h[i];
    }
}

void get_mi(){
    b[1]=2;
    ch[1]=1;
    while(p){
        if(p%2){
            get_cheng_ch();//ch[]乘b[] 
        }
        if(p/2==0)  break;      
        get_cheng_b();//b[]平方 
        p/=2;
    }
}

进一步优化

我从洛谷题解看到，有人两部优化了高精算法:
用一个数组元素存十位数字，只用长度为50的数组就存下了500位；然后把乘2变成乘2^20(这样longlong是完全接受的）。
比模拟乘2快不少，在500位、P=3*10^6数据下时间复杂度与快速幂相当（再加上快速幂岂不是天下无敌?）。
但这样会带来进位的变动和前导零的麻烦。
我就不写了，copy下地址
My AC code:

#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define F(i,a,b) for(int i=a;i<=b;i++)
#define UF(i,a,b) for(int i=a;i>=b;i--)
#define N 1000010
#include <time.h>
using namespace std;
int ch[N], p, len=1,b[N], a=2, len2=1;

void get_cheng_ch(){//多位乘多位 
    int h[len + len2 + 1];
    memset(h, 0, sizeof(h)); 
    int x=0;
    F(i,1,len){
        F(j,1,len2){
            h[i+j-1]+=ch[i]*b[j];
            x=h[i+j-1]/10;
            h[i+j-1]%=10;
            int k = i+j;
            while(x){
                h[k] += x%10;
                x/=10;
                x += h[k]/10;
                h[k] %= 10;
                k++;
            }
        }
    }
    if(h[len+len2]){
        len = min(510,len+len2);
    }
    else
        len = min(510,len+len2-1);
    F(i,1,len){
        ch[i] = h[i];
    }
}
void get_cheng_b(){
    int h[len2+len2+1], x;
    memset(h, 0, sizeof(h));
    F(i,1,len2){
        F(j,1,len2){
            h[i+j-1] += b[i]*b[j];
            x = h[i+j-1]/10;
            h[i+j-1] %= 10;
            int k = i+j;
            while(x){
                h[k] += x%10;
                x /= 10;
                x += h[k]/10;
                h[k] %= 10;
                k++; 
            }
        }
    }
    if(h[len2+len2])    len2 = min(510,len2+len2);
    else    len2 = min(510,len2+len2-1);
    F(i,1,len2){
        b[i] = h[i];
    }
}
void get_jian(){//2^p一定不以0结尾，所以不用这个函数 
    int i=1;
    while(ch[i]==0){
        ch[i] = 9;
        i++;
    }   
    ch[i]--;
    if(ch[len] == 0 && i==len)  len--;
}
void print(int a[], int len){
    cout<<"len2="<<len<<endl;
    UF(i,len,1) 
        cout<<a[i];
    cout << endl;
}
void get_mi(){
    b[1]=2;
    ch[1]=1;
    while(p){
        if(p%2){
            get_cheng_ch();//ch[]乘b[] 
        }
        if(p/2==0)  break;      
        get_cheng_b();//b[]平方 
        p/=2;
//      print(b, len2);
    }
//  get_jian();
}
int main()
{
    cin >> p;
    double anslen;
    anslen=log10(2)*p+1;
    cout<<(int)anslen<<endl;
    get_mi();
//  cout << len << endl;

     
    UF(i,500,2){
        cout << ch[i];
        if((i-1)%50==0) cout << endl;
    }
    cout<<ch[1]-1<<endl; 
//  printf("%lf",(double)clock()/CLOCKS_PER_SEC); 
    return 0;
}

【题解】[P1045] 麦森数

标签：题目   mes   个数   int   精度   表示   cheng   eof   cin   

原文地址：https://www.cnblogs.com/ZhengkunJia/p/12305508.html