我有一个存储在数组a中的n个整数，比如a [0]，a [1]，.....，a [n-1]，其中每个a[i] <= 10^12和n <100。现在，我需要找到这些n个整数的LCM的所有素因子，即{a [0]，a [1]，.....，a [n-1]}
我有一个方法，但我需要一个更有效的方法。
我的方法：
First calculate all the prime numbers up to 10^6 using sieve of Eratosthenes.
For each a[i]
bool check_if_prime=1;
For all prime <= sqrt(a[i])
if a[i] % prime[i] == 0 {
store prime[i]
check_if_prime=0
}
if check_if_prime
store a[i] // a[i] is prime since it has no prime factor <= sqrt(n)
Print all the stored prime[i]'s
有没有更好的方法解决这个问题？
我发布了问题的链接：
http://www.spoj.pl/problems/MAIN12B/
链接到我的代码： http://pastebin.com/R8TMYxNz
解决方案：
正如Daniel Fischer所建议的，我的代码需要一些优化，例如更快的筛选和一些微小的修改。完成所有这些修改后，我就能解决问题。这是我在SPOJ上接受的代码，耗时1.05秒：
#include<iostream>
#include<cstdio>
#include<map>
#include<bitset>
using namespace std;
#define max 1000000
bitset <max+1> p;
int size;
int prime[79000];
void sieve(){
size=0;
long long i,j;
p.set(0,1);
p.set(1,1);
prime[size++]=2;
for(i=3;i<max+1;i=i+2){
if(!p.test(i)){
prime[size++]=i;
for(j=i;j*i<max+1;j++){
p.set(j*i,1);
}
}
}
}
int main()
{
sieve();
int t;
scanf("%d", &t);
for (int w = 0; w < t; w++){
int n;
scanf("%d", &n);
long long a[n];
for (int i = 0; i < n; i++)
scanf("%lld", &a[i]);
map < long long, int > m;
map < long long, int > ::iterator it;
for (int i = 0; i < n; i++){
long long num = a[i];
long long pp;
for (int j = 0; (j < size) && ((pp = prime[j]) * pp <= num); j++){
int c = 0;
for ( ; !(num % pp); num /= pp)
c = 1;
if (c)
m[pp] = 1;
}
if ((num > 0) && (num != 1)){
m[num] = 1;
}
}
printf("Case #%d: %d\n", w + 1, m.size());
for (it = m.begin(); it != m.end(); it++){
printf("%lld\n", (*it).first);
}
}
return 0;
}
如果有人能够以更好的方式或通过更快的方法做到这一点，请告诉我。
答案 0 :(得分：2)
有了这些限制，一些不太大的数字，找到最小公倍数的素因数分解的最佳方法实际上是每个数的因子分解。由于只有78498个素数低于10 6 ，因此试验分区将足够快（除非你真的绝望了最后一滴性能），并将质数筛分为10 6 也只有几毫秒。
如果速度至关重要，试验划分和确定性Miller-Rabin型素数测试与Pollard的rho算法或椭圆曲线因子分解法等因子分解方法的组合方法可能会快一点（但数字如此小，差异不会很大，你需要一个超过64位的数字类型，用于素性测试和因子分解很快。）
在因子分解中，你当然应该删除找到的素数因子
if (a[i] % prime[k] == 0) {
int exponent = 0;
do {
a[i] /= prime[k];
++exponent;
}while(a[i] % prime[k] == 0);
// store prime[k] and exponent
// recalculate bound for factorisation
}
减少检查素数所需的限制。
据我所知，你的主要问题是你的筛子太慢并且占用太多空间（这是造成其缓慢的部分原因）。使用筛子获得更好的缓存局部性，从筛子中移除偶数并停止检查是否在max的平方根处交叉倍数。并且你为主数组分配了太多的空间。
for(int j=0;(prime[j]*prime[j] <= num) && (j<size);j++){
在访问j < size之前，您必须先检查prime[j]。
while(num%prime[j]==0){
c=1;
num /= prime[j];
m[prime[j]]=1;
}
不要多次设置m[prime[j]]。即使std::map非常快，也只比设置一次慢。
答案 1 :(得分：2)
FWIW，为了回应原来要求更快地获得所有素数达到一百万的要求，这里有一个 很多 更快的方法。
这使用了一个基于车轮的Eratosthenes筛子，轮子大小为30，窗口大小设置为搜索上限的平方根（搜索时为1000，最多为1,000,000）。
由于我不熟悉C ++，我已经用C＃编写了它，假设它应该可以很容易地转换为C ++。但是，即使在C＃中，它也可以在大约10毫秒内枚举高达1,000,000的所有质数。即使产生高达十亿的所有素数只需要5.3秒，我想在C ++中这会更快。
public class EnumeratePrimes
{
/// <summary>
/// Determines all of the Primes less than or equal to MaxPrime and
/// returns then, in order, in a 32bit integer array.
/// </summary>
/// <param name="MaxPrime">The hishest prime value allowed in the list</param>
/// <returns>An array of 32bit integer primes, from least(2) to greatest.</returns>
public static int[] Array32(int MaxPrime)
{
/* First, check for minimal/degenerate cases */
if (MaxPrime <= 30) return LT30_32_(MaxPrime);
//Make a copy of MaxPrime as a double, for convenience
double dMax = (double)MaxPrime;
/* Get the first number not less than SQRT(MaxPrime) */
int root = (int)Math.Sqrt(dMax);
//Make sure that its really not less than the Square Root
if ((root * root) < MaxPrime) root++;
/* Get all of the primes <= SQRT(MaxPrime) */
int[] rootPrimes = Array32(root);
int rootPrimeCount = rootPrimes.Length;
int[] primesNext = new int[rootPrimeCount];
/* Make our working list of primes, pre-allocated with more than enough space */
List<int> primes = new List<int>((int)Primes.MaxCount(MaxPrime));
//use our root primes as our starting list
primes.AddRange(rootPrimes);
/* Get the wheel */
int[] wheel = Wheel30_Spokes32();
/* Setup our Window frames, starting at root+1 */
bool[] IsComposite; // = new bool[root];
int frameBase = root + 1;
int frameMax = frameBase + root;
//Pre-set the next value for all root primes
for (int i = WheelPrimesCount; i < rootPrimeCount; i++)
{
int p = rootPrimes[i];
int q = frameBase / p;
if ((p * q) == frameBase) { primesNext[i] = frameBase; }
else { primesNext[i] = (p * (q + 1)); }
}
/* sieve each window-frame up to MaxPrime */
while (frameBase < MaxPrime)
{
//Reset the Composite marks for this frame
IsComposite = new bool[root];
/* Sieve each non-wheel prime against it */
for (int i = WheelPrimesCount; i < rootPrimeCount; i++)
{
// get the next root-prime
int p = rootPrimes[i];
int k = primesNext[i] - frameBase;
// step through all of its multiples in the current window
while (k < root) // was (k < frameBase) ?? //
{
IsComposite[k] = true; // mark its multiple as composite
k += p; // step to the next multiple
}
// save its next multiple for the next window
primesNext[i] = k + frameBase;
}
/* Now roll the wheel across this window checking the spokes for primality */
int wheelBase = (int)(frameBase / 30) * 30;
while (wheelBase < frameMax)
{
// for each spoke in the wheel
for (int i = 0; i < wheel.Length; i++)
{
if (((wheelBase + wheel[i] - frameBase) >= 0)
&& (wheelBase + wheel[i] < frameMax))
{
// if its not composite
if (!IsComposite[wheelBase + wheel[i] - frameBase])
{
// then its a prime, so add it to the list
primes.Add(wheelBase + wheel[i]);
}
// // either way, clear the flag
// IsComposite[wheelBase + wheel[i] - frameBase] = false;
}
}
// roll the wheel forward
wheelBase += 30;
}
// set the next frame
frameBase = frameMax;
frameMax += root;
}
/* truncate and return the primes list as an array */
primes.TrimExcess();
return primes.ToArray();
}
// return list of primes <= 30
internal static int[] LT30_32_(int MaxPrime)
{
// As it happens, for Wheel-30, the non-Wheel primes are also
//the spoke indexes, except for "1":
const int maxCount = 10;
int[] primes = new int[maxCount] {2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };
// figure out how long the actual array must be
int count = 0;
while ((count <= maxCount) && (primes[count] < MaxPrime)) { count++; }
// truncte the array down to that size
primes = (new List<int>(primes)).GetRange(0, count).ToArray();
return primes;
}
//(IE: primes < 30, excluding {2,3,5}.)
/// <summary>
/// Builds and returns an array of the spokes(indexes) of our "Wheel".
/// </summary>
/// <remarks>
/// A Wheel is a concept/structure to make prime sieving faster. A Wheel
/// is sized as some multiple of the first three primes (2*3*5=30), and
/// then exploits the fact that any subsequent primes MOD the wheel size
/// must always fall on the "Spokes", the modulo remainders that are not
/// divisible by 2, 3 or 5. As there are only 8 spokes in a Wheel-30, this
/// reduces the candidate numbers to check to 8/30 (4/15) or ~27%.
/// </remarks>
internal static int[] Wheel30_Spokes32() {return new int[8] {1,7,11,13,17,19,23,29}; }
// Return the primes used to build a Wheel-30
internal static int[] Wheel30_Primes32() { return new int[3] { 2, 3, 5 }; }
// the number of primes already incorporated into the wheel
internal const int WheelPrimesCount = 3;
}
/// <summary>
/// provides useful methods and values for working with primes and factoring
/// </summary>
public class Primes
{
/// <summary>
/// Estimates PI(X), the number of primes less than or equal to X,
/// in a way that is never less than the actual number (P. Dusart, 1999)
/// </summary>
/// <param name="X">the upper limit of primes to count in the estimate</param>
/// <returns>an estimate of the number of primes between 1 and X.</returns>
public static long MaxCount(long X)
{
double xd = (double)X;
return (long)((xd / Math.Log(xd)) * (1.0 + (1.2762 / Math.Log(xd))));
}
}
答案 2 :(得分：1)
http://en.wikipedia.org/wiki/Least_common_multiple
似乎有几种有用的算法特别是http://en.wikipedia.org/wiki/Least_common_multiple#A_method_using_a_table
似乎是合适的。
它将嵌套循环“内向外”并同时处理所有数字，一次一个素数。
因为它一次使用一个素数，你可以在需要时找到下一个素数，避免在开始之前生成10 ^ 6个素数。由于每个数字都因其素数因素而减少，因此测试数字所需的最大素数可能会减少，因此需要的工作量更少。
编辑：它还使终止明确且易于检查，因为当找到所有因素时，该数字减少到1。实际上，当所有数字都减少为1时，它可以终止，但我没有在我的代码中使用该属性。
编辑：我读了这个问题，http://en.wikipedia.org/wiki/Least_common_multiple#A_method_using_a_table的算法直接解决了这个问题。
SWAG： 10 ^ 6以下有78,498个素数（http://primes.utm.edu/howmany.shtml#table） 最糟糕的情况是，有100个数字需要测试78,498个素数， = 7,849,800'mod'操作
没有数字可以通过素数（一个mod和一个除法）成功地因子而不是log2（10 ^ 12）= 43个mods和divides，因此4,300个divdes和4,300个mods，因此由主要测试主导。 为了简单起见，我们称之为8,000,000个整数除法和模数。 它需要产生素数，但正如Daniel Fischer已经说过的那样快。 其余的是簿记。
所以，在现代处理器上，我的WAG大约有1,000,000,000个分频或mod /秒，所以运行时间大约是10ms x 2？
编辑： 我在http://en.wikipedia.org/wiki/Least_common_multiple#A_method_using_a_table
使用了算法没有聪明，正如那里解释的那样。
我估计差不多大约10倍，但仍然只有最大允许运行时间的20％。
性能（通过一些打印来确认结果）
real 0m0.074s
user 0m0.062s
sys 0m0.004s
100个数字：
999979, 999983, 999979, 999983, 999979, 999983, 999979, 999983, 999979, 999983,
10次， 确保几乎所有素数都必须进行测试，因为这似乎是主要的计算。
并且具有相同的打印量，但值几乎为10 ^ 12
real 0m0.207s
user 0m0.196s
sys 0m0.005s
100 999962000357L, // ((long)999979L)*((long)999983L)
gcc --version i686-apple-darwin10-gcc-4.2.1（GCC）4.2.1（Apple Inc. build 5666）（第3点） 版权所有（C）2007 Free Software Foundation，Inc。 这是免费软件;查看复制条件的来源。没有 保证;甚至不适用于适销性或特定用途的适用性。
型号名称：MacBook Pro 处理器名称：Intel Core 2 Duo 处理器速度：2.16 GHz
总结：它显然有效，并且在相对较旧的处理器上运行时间约为允许最大值的20％，这与Daniel Fischer的实现相当。
问题：我是这里的新撰稿人，所以在以下情况下我的回答似乎有点苛刻：
一个。它似乎准确，完整，并且满足所有标准，并且
湾我编写了代码，对其进行了测试，并提供了结果
我做错了什么？如何获得反馈以便我可以改进？
答案 3 :(得分：0)
result := []
for f in <primes >= 2>:
if (any a[i] % f == 0):
result = f:result
for i in [0..n-1]:
while (a[i] % f == 0):
a[i] /= f
if (all a[i] == 1):
break
注意：这只给出了LCM的素数因子列表，而不是LCM的实际值（即不计算指数），我认为这是所需要的全部问题。