NOIP2003普及组（麦森数）

形如2 p-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数。2 p-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数密切相关。
任务：从文件中输入P (1000<P<3100000) ,计算2 p-1的位数和最后500位数字（用十进制高精度数表示）
Input
文件中只包含一个整数P(1000<P<3100000)
Output
第1行：十进制高精度数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

这题的第一问有一个技巧，可以直接通过公式求解。显然可知，在2^p的基础上减一不会对其原本的位数产生影响。
所以可以直接对2^p取对数可以化简为p*lg(2) + 1得到答案。

int P, N, i;
    cin >> P;
    N = P * log10(2) + 1;
    cout << N << endl;

第二问则用到了快速幂和高精度乘高精度的知识，想要在规定的时间内AC一个一个2相乘是过不了的，需要用快速幂将乘法的运算次数缩减。

快速幂的原理：
快速幂其实就是快速求幂的方法，假设我们要求a^b，b可以通过二进制的形式表示：该二进制数第i位的权为2^(i-1)。

例如 b = 13,可以表示为1101，13 = a³+a²+a⁰。很容易就能看出原来是要乘13次，而这里就只要乘3次了。那么该怎么去实现呢?

将幂拆分成二进制后，通过位运算对从右到左的每一位进行逐步处理，遇到0就直接累乘base，遇到1就与原值存储的答案相乘并存储同时继续累乘base。
此处的底base = 2

vector<int> poww(int b) {
    vector<int> A, B;
    string a = "1";
    string base = "2";
    int i;
    for (i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');
    for (i = base.size() - 1; i >= 0; i--) B.push_back(base[i] - '0');
    while (b != 0) {        //快速幂处理
        if (b & 1 != 0) A = mul(A, B); //高精度乘法并存答案
        B = mul(B, B);
        b >>= 1;
    }
    return A;
}

一定要理解为什么累乘base！！！

补充某个大佬的：快速幂取模
根据同余定理，我们知道

（ab）%m = （（a%m）（b%m））%m；

其实快速幂取模也是用到这个

那么根据上面的定理可以推导出另一个定理：

(a^b) mod c = (a * a * a…)%c = ((a%c)(a%c)(a%c)*…)%c = (a%c)^b %c;

**这就是快速幂取模

参考大佬的快速幂
代码如下：**

 int pow_mod(int a, int b) {
    int ans = 1;
    int base = a % c;
    while (b > 0) {
        if (b & 1 != 0) ans = (ans * base) % c;
        　　　　 base = (base * base) % c;
        　　　　 b >>= 1;
        　　　　
    }
    return ans;
}

以下是完整的AC代码：

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
vector<int> mul(vector<int> &A, vector<int> &B) { //高精度乘法函数
    int i, j;
    vector<int> C(A.size() + B.size());
    for (i = 0; i < A.size(); i++) {
        for (j = 0; j < B.size(); j++) {
            C[i + j] += A[i] * B[j];
        }
    }
    int temp = 0;
    for (i = 0; i < C.size(); i++) {
        temp += C[i];
        C[i] = temp % 10;
        temp /= 10;
    }
    while (C.size() < 500) C.push_back(0); //不足500位的补零
    if (C.size() > 500) {	//高于500位直接用resize函数删除后面的位。
        C.resize(500);		//如果不处理会导致超时，因为结果只需考虑后面的500位，超出的部位可以直接删掉，不会影响后面500位存储的数字。
    }
    return C;
}
vector<int> poww(int b) {
    vector<int> A, B;
    string a = "1";
    string base = "2";
    int i;
    for (i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');
    for (i = base.size() - 1; i >= 0; i--) B.push_back(base[i] - '0');
    while (b != 0) {        //快速幂处理
        if (b & 1 != 0) A = mul(A, B);
        B = mul(B, B);
        b >>= 1;
    }
    return A;
}

int main() {
    vector<int> C;
    int P, N, i;
    cin >> P;
    N = P * log10(2) + 1;
    cout << N << endl;
    C = poww(P);
    C[0]--;
    int cnt = 0;
    for (i = C.size() - 1; i >= 0; i--) {
        cout << C[i];
        cnt++;
        if (cnt / 50) {
            cout << endl;
            cnt = 0;
        }
    }
    return 0;
}