Question

假设我只谈论自然数不到1000万的一切。

我希望为10 000 000以下的所有数字预先生成最低素数除数（LPD）列表。例如，LPD（14）== 2，LPD（15）== 3，任何素数的LPD本身就是。

我预先生成了所有的素数。访问第n个素数是一个简单的数组查找。效率为：O（1）

我已经预先生成了一个查找表，用于确定给定的数字是否为素数。访问第n个素数是一个简单的数组查找。效率为：O（1）

现在，我计算给定数字的LPD的天真算法是遍历所有素数，直到一个素数除以数字。但这需要很长时间。我可以在找到所有数字的最低除数的一半时间内生成1000万以下的所有素数（使用Atkin的Sieve，我不理解，但是从伪代码实现）。

是否有更好的算法来计算最低素数除数？

Answer 1

实际上并不确定为什么你会在同样的问题上获得更高的性能。

除非已经标记，否则筛选方法不是划分，而是采用每个素数，将其所有倍数标记为将其自身作为最低素数因子。

int lpf[MAX] = {};
int primes[MAX_PRIME];

for(int i = 0; i < MAX_PRIME; ++i)
{
    int mult = primes[i];
    while(mult < MAX)
    {
       if (lpf[mult] == 0)
       {
            lpf[mult] = primes[i];
       }
       mult += primes[i];
    }
}

最后任何未标记的数字本身都是素数，因此这种方法需要与查找MAX下的所有素数相同的时间。

Answer 2

根据@ Keith的回答改编，新代码运行得更快（旧速度的13％！）：

    public void SieveDivisors() {
        int iNum, iPrime, i6Prime; 
        _iaFirstDivisors = new int[_iLimit];
        _iaFirstDivisors[1] = 1;
        //Start at the largest primes, then work down. This way, we never need to check if the
        // lowest prime multiple is already found, we just overwrite it
        //Also, skip any multiples of 2 or 3, because setting those is a waste of time
        for (int iPrimeIndex = _iaPrimes.Length - 1; iPrimeIndex >= 1; iPrimeIndex--) {
            iPrime = _iaPrimes[iPrimeIndex];
            i6Prime = iPrime * 6;
            for (iNum = iPrime; iNum < _iLimit; iNum += i6Prime) {
                _iaFirstDivisors[iNum] = iPrime;
            }
            for (iNum = iPrime * 5; iNum < _iLimit; iNum += i6Prime) {
                _iaFirstDivisors[iNum] = iPrime;
            }
        }
        //Then record all multiples of 2 or 3
        for (iNum = 3; iNum < _iLimit; iNum += 6) {
            _iaFirstDivisors[iNum] = 3;
        }
        for (iNum = 2; iNum < _iLimit; iNum += 2) {
            _iaFirstDivisors[iNum] = 2;
        }
    }

Answer 3

你说你正在使用Atkin的Sieve来生成素数列表。如果您使用Eratosthenes的筛子，您将自动获得您的LPD阵列 - 它只是您用于筛子的阵列。而不是存储布尔轨道的第一个素数使得数字合成。

这是一些伪C代码：

int lpd[MAX] = {};
int primes[MAX_PRIMES];
int nprimes = 0;

void sieve() {
  for (int p = 2; p*p < MAX; ++p) {
    if (lpd[p] == 0) {
      primes[nprimes++] = p;
      lpd[p] = p;
      for (int q = p*p; q < MAX; q += p) {
        if (lpd[q] == 0) { lpd[q] = p; }
      }
    }
  }
}

最后，数组lpd[]将包含最低素数除数，primes[]将包含素数列表。

（相对）快速找到一个数字的除数＆lt; 10 000 000

3 个答案: