Java 埃拉托什尼问题的筛选：处理非常大的数字

我正在用埃拉托什尼筛解Sphere的在线判断

我的代码适用于提供的测试用例。但是正如问题明确指出的那样：

输入以数字t开始

---

在一行中测试用例（tAe）您是否使用BigInteger类？因为如果不是，我强烈建议在这里使用它。它将处理您正在描述的大数字。如果这还不够好，那么您需要为JVM分配更多内存，通过执行-Xmx作为命令行参数来使用。这里有一个示例：

如果您需要十进制数也是大的，那么也有一个大的十进制数。

这是您的问题：

boolean[] isComposite = new boolean[(int)upperBound + 1];

这将使用大量的空间，因为它为每个布尔值分配4个字节，以允许更快的访问。请使用a来避免这种情况

---

最终，你的数字可能会长时间变大，你将不得不使用BigInteger。但在这一点上，Eratosthenes的筛子可能不会再切割它了。

你正在使用大量空间来存储布尔值。你可能会尝试将每个布尔值压缩为一位。想想看，你真的需要一个布尔值来存储布尔值吗介于下限和上限之间的数字？例如，偶数永远不是素数（2除外），也不是3的所有倍数（3除外）等。这可能会给您一些好主意。

位集实现中有一个小错误。行：

                    isComposite.set(m);

实际上应该是：

                    isComposite.set(k);

---

在该行修复后，代码在测试用例99900000到1000000000上运行时没有错误，抛出4832个素数，从99900017开始，到99999937结束。该位集使用125 MB内存，该方法在我的2.2 GHz笔记本电脑上运行了17秒。

由于Java堆大小的限制，我也遇到了类似的问题。Inste使用高内存整数的ad，转换为布尔值解决了这个问题。 查找所附代码：

public ArrayList<Integer> sieve(int A) {
    boolean prime [] = new boolean[A + 1];
    Arrays.fill(prime, true);
    prime[0] = prime[1] = false;

    for (int i = 2; i <= A; i++) {
        if (!prime[i])
            continue;

        for (long j = 1L * i * i; j <= (long) A; j += i)
            prime[(int) j] = false;
    }

    ArrayList<Integer> res = new ArrayList<>();

    for (int i = 0; i <= A; i++) {
        if (prime[i])
            res.add(i);
    }

    return res;
}

公共数组列表筛选（int A）{
布尔素数[]=新布尔值[A+1]；
数组。填充（prime，true）；
素数[0]=素数[1]=假；
对于（int i=2；i它是BigDecimal，而不是bigdouplespoj PRIME1与纯
int
，它甚至不需要
long
。如果问题从其他地方开始，那么在任务中抛出更大的螺母和螺栓是没有用的……嗯……我如何在10^6之后筛选出更大的数字？我在使用位集时仍然会遇到内存不足的错误。嗯，它仍然超过100MB，因此您必须使用-Xmx选项为JVM提供足够的内存。或者使用我链接到的另一种方法；它的内存使用率较低。@Michael:Atkin的筛子至少需要与Eratosthenes的筛子一样多的内存（渐近
O（sqrt（n）*log（n））
对于因子，
O（n-m+1）
两种情况下的筛子窗口位）。就所有实际用途而言，它总是比可比的埃拉托斯烯筛子需要更多的内存，而且速度总是较慢。这是一个学术练习，不是一个实际的解决方案。
package sphere;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.BitSet;

public class Main{

public static void runEratosthenesSieve(long lowerBound, long upperBound) {

      long upperBoundSquareRoot = (long) Math.sqrt(upperBound);

      //boolean[] isComposite = new boolean[(int)upperBound + 1];

      BitSet isComposite = new BitSet((int)upperBound+1);

      for (int m = 2 /*int m = lowerBound*/; m <= upperBoundSquareRoot; m++) {

            if (!isComposite.get(m)) {

                if (m>=lowerBound) {System.out.println(m);}

                  for (int k = m * m; k <= upperBound; k += m)

                        isComposite.set(m);

            }

      }

      for (int m = (int)upperBoundSquareRoot; m <= upperBound; m++)

            if (!isComposite.get(m))

                 if (m>=lowerBound){ System.out.println(m);}

}

public static void main(String args[]) throws java.lang.Exception{

       BufferedReader r = new BufferedReader(new InputStreamReader(System.in));


       String l = r.readLine();

       int testCases = Integer.parseInt(l); 

       for (int i =0; i<testCases; i++){
       String s =r.readLine();

       String []splitted=s.split(" ");


       long lowerBound = Long.parseLong (splitted[0]);
       long upperBound = Long.parseLong(splitted[1]);

       runEratosthenesSieve (lowerBound,upperBound);

       System.out.println("");
       }
}

}

run:
1
999900000 1000000000
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at java.util.BitSet.initWords(BitSet.java:144)
        at java.util.BitSet.<init>(BitSet.java:139)
        at sphere.Main.runEratosthenesSieve(Main.java:16)
        at sphere.Main.main(Main.java:58)
Java Result: 1
BUILD SUCCESSFUL (total time: 14 seconds)

boolean[] isComposite = new boolean[(int)upperBound + 1];

                    isComposite.set(m);

                    isComposite.set(k);

public ArrayList<Integer> sieve(int A) {
    boolean prime [] = new boolean[A + 1];
    Arrays.fill(prime, true);
    prime[0] = prime[1] = false;

    for (int i = 2; i <= A; i++) {
        if (!prime[i])
            continue;

        for (long j = 1L * i * i; j <= (long) A; j += i)
            prime[(int) j] = false;
    }

    ArrayList<Integer> res = new ArrayList<>();

    for (int i = 0; i <= A; i++) {
        if (prime[i])
            res.add(i);
    }

    return res;
}