从给定的范围内删除给定一组数字的所有倍数

Question

我遇到了一个问题，题目要求给定一个数字N和一组数字S = {s1,s2,.....sn}，其中s1 < s2 < sn < N，从范围1..N中删除所有{s1, s2,....sn}的倍数。

示例：

Let N = 10
S = {2,4,5}
Output: {1, 7, 9}
Explanation: multiples of 2 within range: 2, 4, 6, 8
             multiples of 4 within range: 4, 8
             multiples of 5 within range: 5, 10 

我希望采用算法方法，提供伪代码而非完整解决方案。 我尝试过的：

(Considering the same example as above) 

 1. For the given N, find all the prime factors of that number.
    Therefore, for 10, prime-factors are: 2,3,5,7
    In the given set, S = {2,4,5}, the prime-factors missing from 
    {2,3,5,7} are {3,7}.  
 2. First, check prime-factors that are present: {2,5}
    Hence, all the multiples of them will be removed 
    {2,4,5,6,8,10}
 3. Check for non-prime numbers in S = {4}
 4. Check, if any divisor of these numbers has already been 
    previously processed.
         > In this case, 2 is already processed.
         > Hence no need to process 4, as all the multiples of 4 
           would have been implicitly checked by the previous 
           divisor.
    If not,
         > Remove all the multiples from this range.
 5. Repeat for all the remaining non primes in the set.

请提出您的想法！

- theimpatientcoder

Answer 1

使用类似于埃拉托斯特尼筛法的方法，可以在O(N log(n))的时间复杂度和O(N)的额外内存的条件下解决。

isMultiple[1..N] = false

for each s in S:
    t = s
    while t <= N:
        isMultiple[t] = true
        t += s

for i in 1..N:
    if not isMultiple[i]:
        print i

使用O(N)内存来存储isMultiple数组。

---

时间复杂度为O(N log(n))。事实上，内部while循环将执行N / s₁次，对于S中的第一个元素，然后对于第二个元素将执行N / s₂次，以此类推。

我们需要估计N / s₁ + N / s₂ + ... + N / s_n的数量级。

N / s₁ + N / s₂ + ... + N / s_n = N * (1/s₁ + 1/s₂ + ... + 1/s_n) <= N * (1/1 + 1/2 + ... + 1/n).

最后一个不等式是由于s₁ < s₂ < ... < s_n，因此最坏情况是它们取值{1, 2, .. n}。

然而，调和级数1/1 + 1/2 + ... + 1/n在O(log(n))中，(例如参见这里)，因此上述算法的时间复杂度为O(N log(n))。

- danbanica

Answer 2

基本解决方案：

let set X be our output set.

for each number, n, between 1 and N:
    for each number, s, in set S:
        if s divides n:
            stop searching S, and move onto the next number,n.
        else if s is the last element in S:
            add n to the set X.

在运行此算法之前，您可以明显地删除S中的重复项，但我认为质数不是解决问题的方法。

- Theo Walton

Answer 3

由于S已经排序，我们可以通过跳过已标记的S元素来保证O（N）复杂度（http://codepad.org/Joflhb7x）:

N = 10
S = [2,4,5]
marked = set()
i = 0
curr = 1

while curr <= N:
  while curr < S[i]:
    print curr
    curr = curr + 1

  if not S[i] in marked:
    mult = S[i]

    while mult <= N:
      marked.add(mult)
      mult = mult + S[i]

  i = i + 1
  curr = curr + 1

  if i == len(S):
    while curr <= N:
      if curr not in marked:
        print curr
      curr = curr + 1

print list(marked)

- גלעד ברקן