PAT 1096. Consecutive Factors (20)

地址：http://www.patest.cn/contests/pat-a-practise/1096

这是在pat做的第一个题目， 由于脑残交了十几次才过。

刚看到这个题目第一印象就是一个数的因子数不会太多， 我全找出来就好了， 然后就开始乱搞了， 打素数，分解， 然后找出所有的因子

开始我认为 2^31内的数因子数不会太多，前几个素数是2,3,5,7,11,13,17,19,23, 这几个数乘起来就超了，所以我认为大约一个数的因子数就是2^9的样子，下面的代码在pat上很容易过， 但是很容易构造出让他Segmentation fault (core dumped), 例如 1784742960 = 2^4*3*5*7*11*13*17*19*23, 他的因子个数为5*2^8 = 1280, 越界， 正确的应该在2000, 看来pat的测试数据也是蛮弱的

其实这个题有更简单的暴力解法， 我这么写也是醉了，整天淹没在业务代码里， 智商都弱了

  1 #include<iostream>

  2 #include<algorithm>

  3 #include<cstdio>

  4 #include<cstring>

  5 #include<cmath>

  6 

  7 using namespace std;

  8 

  9 const long long MAXN = 10000000; //这里70000就够了

 10 long long prime[MAXN], plen = 0;

 11 bool notPrime[MAXN];

 12 //工作久了， 命名都改不回来了

 13 void initPrime()

 14 {

 15     long long i, j;

 16     memset(notPrime, 0, sizeof(notPrime));

 17     for (i = 2; i < MAXN; ++i)

 18     {

 19         if (!notPrime[i]) prime[plen++] = i;

 20         for (j = 0; prime[j] * i < MAXN && j < plen; ++j) {

 21             notPrime[prime[j] * i] = true;

 22             if (i % prime[j] == 0) break;

 23         }

 24     }

 25 }

 26 

 27 long long fac[MAXN][2];

 28 int flen = 0;

 29 void split(long long n)

 30 {

 31     flen = 0;

 32     for (int i = 0; i < plen && prime[i] <= n; ++i) {

 33         if (!(n % prime[i])) {

 34             fac[flen][0] = prime[i];

 35             fac[flen][1] = 0;

 36             while(!(n % prime[i])) {

 37                 n /= prime[i];

 38                 ++fac[flen][1];

 39             }

 40             ++flen;

 41         }

 42     }

 43     if (n != 1) {

 44         fac[flen][0] = n;

 45         fac[flen++][1] = 1;

 46     }

 47 }

 48 

 49 const long long MAXFACS = 1000; //这里要2000哟

 50 long long factors[MAXFACS];

 51 int index_factors = 0;

 52 void dfs(long long deep, long long value)

 53 {

 54     if (deep == flen) {

 55         factors[index_factors++] = value;

 56         return;

 57     }

 58     for (int i = 0; i <= fac[deep][1]; ++i) {

 59         dfs(deep + 1, value);

 60         value *= fac[deep][0];

 61 

 62     }

 63 }

 64 

 65 int main()

 66 {

 67     initPrime();

 68     long long n;

 69     while(cin >> n) {

 70         index_factors = 0;

 71         split(n);

 72         dfs(0, 1);

 73         sort(factors, factors + index_factors);

 74         long long max_index = 1;

 75         long long max_key = 1;

 76         int l = 1;

 77         for (int i = 1; i < index_factors; ++i) { //O(n^3)， 能过也是醉了， 绝大多数的数的因子数都不多

 78             bool ok = true;

 79             for (int j = i + 1; j < index_factors; ++j) {

 80                 if (!ok) break;

 81                 long long ret = n / factors[i];

 82                 for (int k = i + 1; k <= j; ++k)

 83                 {

 84                     if (factors[k] != factors[k - 1] + 1)

 85                     {

 86                         ok = false;

 87                         break;

 88                     }

 89                     if (ret % factors[k])

 90                     {

 91                         ok = false;

 92                         break;

 93                     }

 94                     ret /= factors[k];

 95                 }

 96                 if (ok) {

 97                     if (max_key < j - i + 1) {

 98                         max_key = j - i + 1;

 99                         max_index = j;

100                     }

101                 }

102             }

103         }

104         cout << max_key << endl;

105         for (int i = max_index - max_key + 1; i < max_index; ++i) {

106             cout << factors[i] << "*";

107         }

108         cout << factors[max_index] << endl;

109     }

110     return 0;

111 }