有没有办法在c++； 我编写了下面的C++代码来有效地分解大量数字（数字多达24997300729）。 我有一个包含大约41000个素数的向量（我知道有这么大的向量不是一个好主意，但我想不出解决这个问题的方法）。 这段代码立即生成中等大数的素因式分解，但当涉及到24997300572等数字时，程序将暂停

下面是程序和一些输出屏幕截图：

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <cmath>

using namespace std;

vector<int> primes = {paste from  

   https://drive.google.com/file/d/1nGvtMMQSa9YIDkMW2jgEbJk67P7p54ft/view?usp=sharing
};

void factorize(int n) {
    if (n == 1)
        return;
    if (find(primes.begin(), primes.end(), n) != primes.end()) {
        cout << n <<" ";            //if n is prime dont'proceed further
        return;
    }

    //obtaining an iterator to the location of prime equal to or just greater than sqrt(n)
    auto s = sqrt(n);
    vector<int>::iterator it = lower_bound(primes.begin(), primes.end(), s);

    if (it == primes.end()) {
        return;                 // if no primes found then the factors are beyond range
    }
    for (auto i = it;i != primes.begin();i--) {
        if (n % *i == 0)
        {
            cout << *i << " ";
            n = n / (*i);
            factorize(n);
            return;             // the two consecutive for() loops should never run one after another
        }

    }
    for (auto i = it;i != primes.end();i++) {
        if (n % *i == 0)
        {
            cout << *i << " ";
            n = n / (*i);
            factorize(n);
            return;         // the two consecutive for() loops should never run one after another
        }
    }
}

int main() {
    unsigned int n;
    cout << "Enter a number between 1 and 24997300729 ";
    cin >> n;
    if (n > 24997300729) {
        cout << "Number out of range;";
        exit(-1);
    }
    factorize(n);
    return 0;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
向量素数={粘贴自
https://drive.google.com/file/d/1nGvtMMQSa9YIDkMW2jgEbJk67P7p54ft/view?usp=sharing
};
无效因子分解（整数n）{
如果（n==1）
返回；
if（find（primes.begin（），primes.end（），n）！=primes.end（））{
cout现在有点不清楚（至少对我来说）你为什么要用你现在的方式组织这个程序

只需查找小于或等于某个数的平方根的素数因子，即可对该数进行完全因子运算。任何大于一个素数因子小于该数的素数因子对的素数因子，因此只需搜索这些素数因子即可找到所有的素数因子。任何剩余因子都可以通过简单的除法获得，而不是搜索

我可能会动态生成素数的基数（大部分可能使用筛子）。24'997'300'729的平方根约为158'105。快速测试表明，即使没有任何优化工作，一个埃拉托什尼筛子也会在大约12毫秒内找到达到该限值的素数

就个人而言，我不希望对用户可以计算的最大数有固定的限制，而不是对我们正在处理的数的大小有限制，因此，如果用户输入接近64位数限制的值，我们会找到所有适合32位的素数，然后用它们来计算数。这显然比我们找不到那么多的素数，但是用户可能不会对分解一个较大的数比分解一个较小的数花费更长的时间的想法感到太惊讶

因此，要实现这一点，我们可能会得到如下代码：

#include <iostream>
#include <locale>
#include <vector>
#include <string>

using Number = unsigned long long;

auto build_base(Number limit) {
    std::vector<bool> sieve(limit / 2, true);

    for (Number i = 3; i < limit; i += 2) {
        if (sieve[i / 2]) {
            for (Number temp = i * i; temp < limit; temp += i)
                if (temp & 1)
                    sieve[temp / 2] = false;
        }
    }
    return sieve;
}

void factor(Number input, std::vector<bool> const &candidates)
{
    while (input % 2 == 0) {
        std::cout << 2 << "\t";
        input /= 2;
    }

    for (Number i = 1; i < candidates.size(); i++) {
        if (candidates[i]) {
            auto candidate = i * 2 + 1;
            while ((input % candidate) == 0) {
                    std::cout << candidate << "\t";
                    input /= candidate;
            }
        }
    }
    if (input != 1)
        std::cout << input;
}

int main(int argc, char **argv) {
    std::cout.imbue(std::locale(""));

    if (argc != 2) {
        std::cerr << "Usage: factor <number>\n";
        return EXIT_FAILURE;
    }

    auto number = std::stoull(argv[1]);
    auto limit = std::sqrt(number) + 1;
    auto candidates = build_base(limit);

    factor(number, candidates);
}

#包括
#包括
#包括
#包括
使用数字=无符号长；
自动生成基础（数量限制）{
标准：：向量筛（限值/2，真值）；
对于（数字i=3；istd：：不能只是一个注释——最后我们有一个与算法相关的问题，接近a，测试数据包含在代码中，没有使用臭名昭著的
标题等。恭喜。你只需要删除超链接，并使
n
等于测试量。
n
只是一个
int
，但是你id您试图将其设置为
24997300572
，这超出了
int
的范围。
n
应为64位整数类型，即
long
。然后您需要更改假定
n
为64位的其余代码，例如，必须更改
factorize
函数的参数。Wh在第二个循环中，“41000个素数”小于1兆字节，也就是说，在大多数台式机上没有太多内存。无需猜测（长整型？）使用整型64_t，并知道你的整型是什么大小。“整型最大值是19个字符（9223372036854775807）”和“UINTMAX是20个字符（18446744073709551615）”看，如果你能稍微解释一下你的代码，那就太好了，因为它工作得很好，但我不太理解它：-我刚刚意识到代码不可靠：-）举个例子，172917933876889=168781*43*7*340369都是素数；但是把它作为输入会产生12372375950351作为因子；这种情况发生是因为在你的代码中你没有检查sqrt（n）之外的素数（我在第一次尝试中也是这样做的，以最小化时间），但在sqrt（n）之外还有n的素数因子；因此，为了说明这一点，您有两个选项：1.一旦获得了小于sqrt（n）的素数因子p，再次执行递归搜索（n/p），并将其添加到因子列表中（就像我所做的那样）；进行另一次快速检查，172917933876889/7给出24702561982412.714285714285714286。换句话说，否，7不是172917933876889的系数。