题目

题目描述

形如2P-1**的素数称为麦森数,这时P一定也是个素数。但反过来不一定,即如果P是个素数,**2P-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 是 3*106,也就是要成3*106次2。

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

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

乘3*106次2,就要运算3*1012次,肯定要超时。

考虑用快速幂。

快速幂,是将3*106次乘2优化到log级别,也就是log2(3*106)大约是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的幂,最大更新到2P(比如P=64时,264=2^64),

也就是说,b[]的长度最大是2(3*106),不也还是10^6吗?

每调用一次get_cheng_b()函数,就要运行(106)2次(高精乘高精,时间复杂度是平方级别),

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

咋办?

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

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

位数怎么搞?

是2P-1的位数,与2P的位数一样。

注意到10^m的位数是m+1。

我们将2^P转化为以10为底,这样次数加一就是位数。

设次数为x,10x=2P,

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] 麦森数的更多相关文章

  1. P1045麦森数

    P1045麦森数 #include<iostream> #include <cmath> #include <cstring> const int maxn = 1 ...

  2. 洛谷试炼场-简单数学问题-P1045 麦森数-高精度快速幂

    洛谷试炼场-简单数学问题 B--P1045 麦森数 Description 形如2^P−1的素数称为麦森数,这时P一定也是个素数.但反过来不一定,即如果PP是个素数,2^P-1 不一定也是素数.到19 ...

  3. 洛谷 P1045 麦森数

    题目描述 形如2^{P}-1的素数称为麦森数,这时P一定也是个素数.但反过来不一定,即如果P是个素数,2^{P}-1不一定也是素数.到1998年底,人们已找到了37个麦森数.最大的一个是P=30213 ...

  4. 洛谷P1045 麦森数

    题目描述 形如2^{P}-12 ​P ​​ −1的素数称为麦森数,这时PP一定也是个素数.但反过来不一定,即如果PP是个素数,2^{P}-12 ​P ​​ −1不一定也是素数.到1998年底,人们已找 ...

  5. 洛谷 P1045 麦森数 (快速幂+高精度+算位数骚操作)

    这道题太精彩了! 我一开始想直接一波暴力算,然后叫上去只有50分,50分超时 然后我改成万位制提高运算效率,还是只有50分 然后我丧心病狂开long long用10的10次方作为一位,也就是100亿进 ...

  6. NOIP2003 普及组 洛谷P1045 麦森数 (快速幂+高精度)

    有两个问题:求位数和求后500位的数. 求位数:最后减去1对答案的位数是不影响的,就是求2p的位数,直接有公式log10(2)*p+1; 求后500位的数:容易想到快速幂和高精度: 1 #includ ...

  7. P1045 麦森数

    别问我为什么要写水题 #include <iostream> #include <cstdio> #include <cstring> #include <a ...

  8. P1045 [NOIP2003 普及组] 麦森数

    题目描述 形如2^P−1的素数称为麦森数,这时P一定也是个素数.但反过来不一定,即如果P是个素数,2^P−1不一定也是素数. 到1998年底,人们已找到了37个麦森数.最大的一个是P=3021377, ...

  9. 【03NOIP普及组】麦森数(信息学奥赛一本通 1925)(洛谷 1045)

    [题目描述] 形如2P-1的素数称为麦森数,这时P一定也是个素数.但反过来不一定,即如果P是个素数,2P-1不一定也是素数.到1998年底,人们已找到了37个麦森数.最大的一个是P=3021377,它 ...

随机推荐

  1. 关于Mach-O类型文件那点事

    Mach-O文件简介   Mach-O是一种文件格式,是Mach Object文件格式的缩写. 它通常应用于可执行文件,目标代码,动态库,内核转储等中.   Mach-O作为大部分基于Mach核心的操 ...

  2. Objectarx 相交矩形求并集 面域转多段线

    测试结果: 主要思路:拾取一个点作为矩形的插入点,分别以该点进行两次jig操作,就能得到白色的两个相交的polyline,之后需要变成红色的封闭多段线.做法就是:求出两个白色矩形的面域,然后通过boo ...

  3. BFT-SMaRt:用Netty做客户端的可靠信道

    目录 一.Netty服务端的构建 1. 父类构造函数 ① 查找缓存 ② 相关日志 2. 服务端构造 ① 配置读取 ② 服务端配置 3. 服务端功能 ① 通用接口功能 ② Channel处理器 4. 节 ...

  4. SPSS 相关性的选择

    在SPSS中导入数据,analyze-correlate-bivariate-选择变量 OK 输出的是相关系数矩阵 相关系数下面的Sig.是显著性检验结果的P值,越接近0越显著. 同样的数据,我们接着 ...

  5. KVM管理工具 WebVirtMgr

    WEB管理工具 WebVirtMgr WebVirtMgr是一个基于libvirt的Web界面,用于管理虚拟机.它允许您创建和配置新域,并调整域的资源分配.VNC查看器为来宾域提供完整的图形控制台.K ...

  6. lisp学习总结(一)

    lisp太简单 lisp核心太简单了只有几个简单的逻辑定理,简单到你会认为他啥事都做不了. lisp语法太简单了,只有符号,参数,以及括号,组成一种万能的表达式. 由于上述lisp的简单,所以对于初学 ...

  7. Codeforces Round #615 (Div. 3)

    A. Collecting Coins 题目链接:https://codeforces.com/contest/1294/problem/A 题意: 你有三个姐妹她们分别有 a , b , c枚硬币, ...

  8. [bzoj2286] [洛谷P2495] [sdoi2015] 消耗战

    Description 在一场战争中,战场由 \(n\) 个岛屿和 \(n-1\) 个桥梁组成,保证每两个岛屿间有且仅有一条路径可达.现在,我军已经侦查到敌军的总部在编号为1的岛屿,而且他们已经没有足 ...

  9. isinstance 和type

    推荐使用 isinstance 判断对象类型. isinstance 的用法: 语法: isinstance(object, classinfo) 其中,object 是变量,classinfo 是类 ...

  10. HGE引擎改进——2014/3/4

    2014/3/4 更新 1.提升资源包管理效率 2.Show库整合.目前Show库有Picture.Frame.Animation和Particle类,以及PictureData和ParticleSy ...