找到给定数字以下的2个素数的最大乘积

Question

给定一个数 N，我们如何找到最大 P*Q

我的（蛮力）尝试：

• 找到所有素数 P 的列表 {P, N/P}
• 找到素数 Q 的列表，使得 Q 是正下方的最大素数 上面列表中的 N/P
• 从上面确定最大乘积 P*Q

虽然这种蛮力方法可行，但是否有正式（更明智）的解决方案来解决这个问题？

示例：N=27

√N = 5.196

Candidate primes: 2,3,5 --> [{2,13.5},{3,9},{5,5.4}] ->[{2,13},{3,7},{5,5}]

Solution: Max([2*13, 3*7, 5*5]) = 2*13 = 26

因此，蛮力解决方案有效。

更进一步，我们看到 Q_max = √N。

我们可以将我们的解决方案集优化为仅那些值 {P, N\2}，其中 N\2 >= √N。

我选择了整数除法“\”，因为我们只对整数值感兴趣，而且整数除法确实比常规除法“/”快得多

问题简化为：

示例：N=27

√N = 5.196

Candidate P: 2,3 --> [{2,13},{3,9}] -->[{2,13},{3,7}]

(we drop {5,5} since N\P < √N i.e. 5 < 5.196)

Solution set: max([2*13, 3*7]) = 2*13 = 26

它可能看起来微不足道，但它只是消除了 1/3 的可能解决方案集。

我们可以添加其他巧妙的程序来进一步减少集合吗？

Answer 1

另一个蛮力尝试：

1. 查找所有素数 p
2. 从最小的 p 开始迭代数组，只要 p

如果有足够的内存可用（N/2 位），可以制作一个该大小的位数组。除第一个位置外，使用所有 TRUE 对其进行初始化。遍历位数组，计算您所在位置的倍数并将所有倍数设置为 false。如果下一个位置已经为假，则不需要重新计算它的所有倍数，它们已经设置为假。

因此找到所有素数是

a[1] := false;
m := n \ 2; // sizeof(a)
for i := 2 to m do
   a[i] := true;
for i := 2 to m do
   if a[i] then
     for j := 2*a[i] to m step a[i] do
       a[i*j] := false;

步骤 2) 也是

result := 0;
for i := 2 to √N do
  if not a[i] then continue; // next i;
  for j := (n \ i) downto i do
     if not a[j] then continue; // next j
     if a[j] * a[i] < N
        result :=  max(result, a[j] * a[i]);
        break; // next i;
  if result = N then break; // you are finished

我猜这可以进一步优化。你可以保持 (i,j) 知道这两个素数。

Answer 2

这类似于 @RalphMRickenback 所描述的，但具有更严格的复杂性界限。

他描述的素数查找算法是sieve of Erathostenes，它需要空间O(n)，但时间复杂度O(n log log n)，如果你想了解更多可以看维基百科上的讨论小心这个。

找到小于n // 2 的素数列表后，您可以一次扫描它，即具有 O(n) 复杂度，方法是让一个指针从开头开始，另一个指针在结尾。如果这两个素数的乘积大于您的值，请减小高指针。如果乘积较小，则将其与存储的最大乘积进行比较，并增加低位指针。

EDIT 正如 cmets 中提到的，素数扫描的时间复杂度在n 上优于线性，因为它仅在小于n 的素数上，所以 O (n / log n)。

这里是 Python 的完整实现，而不是伪代码：

def prime_sieve(n):
    sieve = [False, False] + [True] * (n - 1)

    for num, is_prime in enumerate(sieve):
        if num * num > n:
            break
        if not is_prime:
            continue
        for not_a_prime in range(num * num, n + 1, num):
            sieve[not_a_prime] = False

    return [num for num, is_prime in enumerate(sieve) if is_prime]

def max_prime_product(n):
    primes = prime_sieve(n // 2)

    lo, hi = 0, len(primes) - 1
    max_prod = 0
    max_pair = None

    while lo <= hi:
        prod = primes[lo] * primes[hi]
        if prod <= n:
            if prod > max_prod:
                max_prod = prod
                max_pair = (primes[lo], primes[hi])
            lo += 1
        else:
            hi -= 1
    return max_prod, max_pair

你的例子会产生：

>>> max_prime_product(27)
(26, (2, 13))