PAT A 1096（甲级）

最新推荐文章于 2024-07-08 00:17:11 发布

CrazyOnes

最新推荐文章于 2024-07-08 00:17:11 发布

阅读量809

点赞数 4

CC 4.0 BY-SA版权

分类专栏： PAT练习题文章标签： PAT PAT甲级算法因子分解

本文链接：https://blog.youkuaiyun.com/CrazyOnes/article/details/81711339

PAT练习题专栏收录该内容

40 篇文章

订阅专栏

这道题目要求找到正整数N的最大连续因子个数及其最小序列。通过暴力搜索[2, sqrt(N)]范围内的连续因子，判断其是否为N的因子。正确解题思路是避免质因子分解，直接寻找连续因子序列，确保因子乘积不超过N。错误的编程尝试包括错误地考虑质因子与连续因子的关系，导致逻辑漏洞。最后，采用正确思路实现的AC代码完成任务。" 79588159,5711140,VBA自动化：合并文件夹内Excel文件并记录文件名,"['VBA编程', 'Excel工具', '数据处理', '自动化办公']

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1096 Consecutive Factors (20)（20 分）

作者: CHEN, Yue

单位: PAT联盟

时间限制: 400ms

内存限制: 64MB

代码长度限制: 16KB

Among all the factors of a positive integer N, there may exist several consecutive numbers. For example, 630 can be factored as 3*5*6*7, where 5, 6, and 7 are the three consecutive numbers. Now given any positive N, you are supposed to find the maximum number of consecutive factors, and list the smallest sequence of the consecutive factors.

Input Specification:

Each input file contains one test case, which gives the integer N (1<N<2^31^).

Output Specification:

For each test case, print in the first line the maximum number of consecutive factors. Then in the second line, print the smallest sequence of the consecutive factors in the format "factor[1]*factor[2]*...*factor[k]", where the factors are listed in increasing order, and 1 is NOT included.

Sample Input:

Sample Output:

3
5*6*7

这道题我是按照《算法笔记》的顺序来刷的，《算法笔记》把这道题放到了“质因子分解”一节中，其实也让我走了一些思维的弯路。

首先这道题和质因子毫无关系，如果一开始以分解因子的思路去思考的话可能会更接近正确的答案。

然后说一下这道题正确的思路吧，其实就是分解因子，而且是以非常暴力的手段去寻找连续因子，判断以2开始不断加一形成的序列是否是n的因子，如果不是记录当前连续的因子头和长度，以3开始接着试。直到多少为止呢，从质因子这一节我们有一个结论就是，对于一个大于等于2的整数n，它的因子至多有一个大于等于 $\sqrt{n}$ ，所以我们可以放心的在[2, $\sqrt{n}$ ] 这个范围去寻找连续因子，如果最大长度只有1，也必定是小于 $\sqrt{n}$ 的那个因子或者是他本身。

到这里本体所有的解析就结束了，编码方面没有什么我觉得特别需要注意的坑。后面是我的一些错误反思总结，如果有兴趣大家可以读一下。

在一开始我一直想要寻找这些连续因子和质因子之间的关系，当然我只找到了一个显而易见的结论就是这些连续的因子都是由这个数的质因子经过某种乘积组合而成的，但是并没有看出和连续的因子有什么关系。然而当我尝试着写一个数将其分解时，发现我可以把这个数所有的因子都计算出来，然后遍历一下这个因子列表，就可以看到最长连续的因子，同时为了防止错误，可以每次多一个连续因子时就让这个序列进行乘积，将得到的结果与n比较，要至少<=n，在我当时看来是完全正确的，并开始了编程。

但是当我编写完成之后提交结果并不理想，于是我就随便找了一组数据来测试 15 * 16 * 17 = 4080，我以为得到的结果会是 15 16 17，但是其实得到的结果是2 3 4 5 6，但我仔细计算这个数据发现结果也是错误的，正确的结果应该是 2 3 4 5 ，没有6，将4080分解成质因子之后只有 3个2，如果再加上6的话是有4个2了，错误的原因其实就是在当时我的逻辑漏洞，虽然我保证了最长连续因子不会比n大，但是比n小的情况不一定是合理的。

于是我想到了通过对结果分解质因子和n分解质因子，比较是不是最长连续因子的某个质因子比n能分解出来的多，就是不合理的，当然最后我做完之后发现这个工程量是在太大，小两百行的代码量，但是最后还是有一个测试点没有通过，很遗憾，我也就没有去自习研究错误的地方，不想在绕远的路上走太远。

回到正确思路上，其实我的思路和正确思路相差就一个点，如果我当时记录一个连续因子就用 n /= x 让计算之后的n再去寻找下一个连续因子就不会出现不合理的结果了。

所以还是需要更严谨，更多方面的思考，继续努力了。

AC代码

#include <cstdio>
#include <math.h>

int main() {
    int n, maxLen = 0, s;

    scanf("%d", &n);
    int sn = (int)sqrt(1.0 * n);
    for(int i = 2; i <= sn; ++i) {
        int len = 0, temp = i, k = i;
        while(n % temp == 0) {
            ++len;
            ++k;
            temp *= k;
        }

        if(len > maxLen) {
            s = i;
            maxLen = len;
        }
    }

    if(maxLen == 0) {
        printf("1\n");
        printf("%d\n", n);
    } else {
        printf("%d\n", maxLen);
        for(int i = 0; i < maxLen; ++i) {
            if(i != 0) {
                printf("*");
            }
            printf("%d", s + i);
        }
    }

    return 0;
}

绕远思路的最终代码：

#include <cstdio>
#include <math.h>

struct Factor {
    int x, cnt;
}fac[20];

const int maxn = 100010;
int num[10000000];
int prime[maxn];
bool p[maxn] = {0};
int pNum = 0;
int fNum = 0;

bool isPrime(int);
void calPrimeTable();
void calPrimeFac(int);

int main() {
    int n, maxLen = 0, maxPos;

    scanf("%d", &n);
    if(isPrime(n)) {
        printf("1\n");
        printf("%d", n);
    } else {
        calPrimeTable();
        calPrimeFac(n);
        int k = 0;
        for(int i = n; i >= 2; --i) {
            if(n % i == 0) {
                num[k++] = i;
            }
        }

        for(int i = 0; i < k; ++i) {
            int pos, len = 0, total = 1;
            for(int j = i; j < k; ++j) {
                if(len == 0) {
                    pos = j;
                    total *= num[j];
                    ++len;
                } else {
                    if(num[j - 1] == num[j] + 1 && total * num[j] <= n) {
                        ++len;
                    } else {
                        break;
                    }
                }
            }

            if(len >= maxLen) {
                if(len > 1) {
                    Factor nfac[20];
                    int nfNum = 0;
                    for(int j = 0; j < len; ++j) {
                        int tar = num[pos + j];

                        for(int h = 0; prime[h] <= (int)sqrt(1.0 * tar); ++h) {
                            if(tar % prime[h] == 0) {
                                int m = 0;
                                while(m < nfNum && nfac[m].x != prime[h]) {
                                    ++m;
                                }

                                if(m == nfNum) {
                                    nfac[m].x = prime[h];
                                    nfac[m].cnt = 0;
                                }

                                while(tar % prime[h] == 0) {
                                    ++nfac[m].cnt;
                                    tar /= prime[h];
                                }

                                if(m == nfNum) {
                                    ++nfNum;
                                }
                            }
                        }

                        if(tar != 1) {
                            int m = 0;
                            while(m < nfNum && nfac[m].x != tar) {
                                ++m;
                            }

                            if(m == nfNum) {
                                nfac[nfNum].x = tar;
                                nfac[nfNum++].cnt = 1;
                            } else {
                                ++nfac[m].cnt;
                            }
                        }
                    }

                    bool agree = true;
                    for(int j = 0; j < nfNum; ++j) {
                        bool find = false;
                        for(int n = 0; n < fNum; ++n) {
                            if(fac[n].x == nfac[j].x && fac[n].cnt >= nfac[j].cnt) {
                                find = true;
                                break;
                            }
                        }
                        if(!find) {
                            agree = false;
                            break;
                        }
                    }

                    if(!agree) {
                        continue;
                    }
                }
                maxLen = len;
                maxPos = pos;
            }
        }

        printf("%d\n", maxLen);
        for(int i = maxLen; i > 0; --i) {
            if(i != maxLen) {
                printf("*");
            }
            printf("%d", num[i + maxPos - 1]);
        }
    }

    return 0;
}

bool isPrime(int a) {
    if(a <= 1) {
        return false;
    }

    int sa = (int)sqrt(1.0 * a);
    for(int i = 2; i <= sa; ++i) {
        if(a % i == 0) {
            return false;
        }
    }

    return true;
}


void calPrimeTable() {
    for(int i = 2; i < maxn; ++i) {
        if(!p[i]) {
            prime[pNum++] = i;
            for(int j = i + i; j < maxn; j += 2) {
                p[j] = true;
            }
        }
    }
}

void calPrimeFac(int n) {
    for(int i = 0; prime[i] <= (int)sqrt(1.0 * n); ++i) {
        if(n % prime[i] == 0) {
            fac[fNum].x = prime[i];
            fac[fNum].cnt = 0;
            while(n % prime[i] == 0) {
                ++fac[fNum].cnt;
                n /= prime[i];
            }
            ++fNum;
        }
    }

    if(n != 1) {
        fac[fNum].x = n;
        fac[fNum++].cnt = 1;
    }
}

如有错误，欢迎指摘。