POJ2689 Prime Distance

最新推荐文章于 2020-09-18 17:27:02 发布

nevergiveup23

最新推荐文章于 2020-09-18 17:27:02 发布

阅读量745

点赞数

CC 4.0 BY-SA版权

分类专栏： POJ_JAVA 文章标签： distance string

本文链接：https://blog.youkuaiyun.com/nevergiveup23/article/details/3033561

POJ_JAVA 专栏收录该内容

51 篇文章

订阅专栏

本文介绍了一种用于找出特定范围内所有素数的有效算法。通过构造一个小的素数表，并利用该表来筛选出指定区间内的素数，适用于处理较大数值的情况。

题目：http://acm.pku.edu.cn/JudgeOnline/problem?id=2689

思路：找出不大于1000000的范围的素数。但是这个值可能很大，所以必须用筛选才能做。

可以先构造一个小的素数表，在进行区间的素数的筛选，这个小素数表的范围是2~sqrt(Integer.MAX_VALUE)。还有中间的处理可能会越界，小心处理。

 
 import java.util.Scanner;
public class Main {
    final static int MAXVALUE = (int) Math.sqrt(Integer.MAX_VALUE) + 1;
    public static void main(String[] args) {
        int k, l, u, tt, index;
        boolean hasFlg;
        int a, b, aa, bb;
        int[] num = new int[MAXVALUE];
        boolean[] frimeflg = new boolean[MAXVALUE];
        boolean[] flg;
        index = 1;
        // 构造一个小素数表 
        for (int i = 2; i < MAXVALUE; i++) {
            if (!frimeflg[i]) {
                k = i * 2;
                num[index++] = i;
                while (k < MAXVALUE) {
                    frimeflg[k] = true;
                    k += i;
                }
            }
        }
        Scanner scan = new Scanner(System.in);
        while (scan.hasNextInt()) {
            l = scan.nextInt();
            u = scan.nextInt();
            tt = (int) Math.sqrt(u);
            // 构造一个u-l+1的区间 
            flg = new boolean[u - l + 1];
            // 筛选区间，不是素数的标记为true 
            for (int i = 1; i < index && i <= tt; i++) {
                k = Math.max(num[i], l / num[i]);
                if (k * num[i] < l || k <= 1) {
                    k++;
                }
                if (k <= 1) {
                    k++;
                }
                while ((long) k * num[i] <= u) {
                    flg[k * num[i] - l] = true;
                    k++;
                }
            }
            hasFlg = false;
            a = 0;
            b = Integer.MAX_VALUE;
            aa = 0;
            bb = 0;
            if (l == 1) {
                flg[0] = true;
            }
            for (int i = 0; i < u - l + 1; i++) {
                if (!flg[i]) {
                    for (int j = i + 1; j <= u - l; j++) {
                        if (!flg[j]) {
                            if (b - a > j - i) {
                                a = i + l;
                                b = j + l;
                            }
                            if (bb - aa < j - i) {
                                bb = j + l;
                                aa = i + l;
                            }
                            hasFlg = true;
                            break;
                        }
                    }
                }
            }
            if (hasFlg) {
                System.out.printf(
                        "%d,%d are closest, %d,%d are most distant./n", a, b,
                        aa, bb);
            } else {
                System.out.println("There are no adjacent primes.");
            }
        }
    }
}