sicily 1009 梅森素数

1009. Mersenne Composite N

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB

Description

One of the world-wide cooperative computing tasks is the "Grand Internet Mersenne Prime Search" -- GIMPS -- striving to find ever-larger prime numbers by examining a particular category of such numbers. 
A Mersenne number is defined as a number of the form (2^p–1), where p is a prime number -- a number divisible only by one and itself. (A number that can be divided by numbers other than itself and one are called "composite" numbers, and each of these can be uniquely represented by the prime numbers that can be multiplied together to generate the composite number — referred to as its prime factors.) 
Initially it looks as though the Mersenne numbers are all primes. 

Prime	Corresponding Mersenne Number
2	4–1 = 3 -- prime
3	8–1 = 7 -- prime
5	32–1 = 31 -- prime
7	128–1 = 127 -- prime

If, however, we are having a "Grand Internet" search, that must not be the case. 
Where k is an input parameter, compute all the Mersenne composite numbers less than 2 ^k -- where k <= 63 (that is, it will fit in a 64-bit signed integer on the computer). In Java, the "long" data type is a signed 64 bit integer. Under gcc and g++ (C and C++ in the programming contest environment), the "long long" data type is a signed 64 bit integer.

Input

Input is from file a. in. It contains a single number, without leading or trailing blanks, giving the value of k. As promised, k <= 63.

Output

One line per Mersenne composite number giving first the prime factors (in increasing order) separate by asterisks, an equal sign, the Mersenne number itself, an equal sign, and then the explicit statement of the Mersenne number, as shown in the sample output. Use exactly this format. Note that all separating white space fields consist of one blank.

Sample Input

31

Sample Output

23 * 89 = 2047 = ( 2 ^ 11 ) - 1
47 * 178481 = 8388607 = ( 2 ^ 23 ) - 1
233 * 1103 * 2089 = 536870911 = ( 2 ^ 29 ) - 1

这道题也是坑的一笔，有几点需要切切注意

（1）     long   long   temp=  pow (2,p) - 1;

    求幂之后一定要用long long 来保存，比如，如果直接输出pow（2，31）会出现精度损失，因为系统默认用int来处理

（2）分解质因数时，一定要for (i = 2; i*i <= temp;i++)这样写，而不能把判断条件改为i<=temp，那样就会超时了，用i*i之后，记得加上一句话对特殊情况做处理（factor是用来存储因数的）

if (temp != 1)

factor.push_back(temp);

  因为，不能把1也当作因数来存储，我们要的是素数。

代码见下：

// Problem#: 1009
// Submission#: 3014941
// The source code is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// URI: http://creativecommons.org/licenses/by-nc-sa/3.0/
// All Copyright reserved by Informatic Lab of Sun Yat-sen University
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <iomanip>
using namespace std;

vector<long long> cal(int p)
{
    long long temp = pow(2, p) - 1;
    vector<long long> factor; 
    long long i;
    for (i = 2; i*i <= temp; i++)
    {
        while (temp % i == 0)
        {
            temp /= i;
            factor.push_back(i);
        }
    }
    if (temp != 1)
        factor.push_back(temp);
    return factor;
}

int main()
{
    int prime[9] = { 11, 23, 29, 37, 41, 43, 47, 53, 59 };
    int T;
    cin >> T;
    for (int i = 0; i < 9; i++)
    {
        if (prime[i] <= T)
        {
            vector<long long> res = cal(prime[i]);
            int j;
            for (j = 0; j < res.size() - 1; j++)
            {
                cout << res[j] << " * ";
            }
            long long m = pow(2, prime[i]) - 1;
            cout << fixed << setprecision(0) << res[j] << " = " << m << " = ( 2 ^ " << prime[i] << " ) - 1" << endl;
        }
    }
    return 0;
}