在最短的时间内找到排除某些元素的数组的最大公约数 (GCD)

Question

我正在做一个有竞争力的编程问题，给你一个数字数组，然后是一定数量的查询。对于每个查询，您将获得 2 个整数，“a”和“b”。所以你应该输出数组中剩余元素的 GCD（不包括 a、b 以及它们之间的所有元素）。

例如，如果数组是：16,8,24,15,20，并且有 2 个查询 (2, 3) 和 (1, 3)，则输出 1 为：1，输出 2 为：5。 请注意，索引是基于 1 的。

这是我的代码，我在其中实现了基本思想，其中包含一个用于查找传递给它的数组的 GCD 的函数。

public static void main(String args[]) throws IOException {

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(br.readLine());

    while (t-- > 0) {   //This is the number of test cases
        String[] s1 = br.readLine().split(" ");
        int n = Integer.parseInt(s1[0]);          //Number of elements in array
        int q = Integer.parseInt(s1[1]);          //Number of queries

        String[] s2 = br.readLine().split(" ");
        int[] arr = new int[n];

        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(s2[i]);
        }

        for (int i = 0; i < q; i++) {            //for each query
            String[] s3 = br.readLine().split(" ");
            int a = Integer.parseInt(s3[0]) - 1;
            int b = Integer.parseInt(s3[1]) - 1;

            int[] copy = new int[n - b + a - 1];     //this is so that the original array doesn't get messed up

            int index = 0;
            for (int j = 0; j < n; j++) {       //filing the array without the elements of the query
                if (j < a || j > b) {
                    copy[index] = arr[j];
                    index++;
                }
            }

            int fin = gcd(copy);
            System.out.println(fin);

        }

    }

}

private static int gcd(int a, int b) {
    while (b > 0) {
        int temp = b;
        b = a % b; // % is remainder
        a = temp;
    }
    return a;
}

private static int gcd(int[] input) {        //simple GCD calculator using the fact that GCD(a,b,c) === GCD((a,b),c)
    int result = input[0];
    for (int i = 1; i < input.length; i++)
        result = gcd(result, input[i]);
    return result;
}

问题是我在某些部件上获得了 AC（十分之六），而在其余部分上获得了 TLE。有人可以提出更好的方法来解决这个问题，因为我的方法似乎太慢了，几乎不可能进一步优化？

Answer 1

您可以预先计算所有前缀和后缀的 gcd。每个查询都是前缀和后缀的联合，因此需要O(log MAX_A) 时间来回答一个。这是我的代码：

import java.util.*;
import java.io.*;

public class Solution {

    static int gcd(int a, int b) {
        while (b != 0) {
            int t = a;
            a = b;
            b = t % b;
        }
        return a;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(
                new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int tests = Integer.parseInt(br.readLine());
        for (int test = 0; test < tests; test++) {
            String line = br.readLine();
            String[] parts = line.split(" ");
            int n = Integer.parseInt(parts[0]);
            int q = Integer.parseInt(parts[1]);
            int[] a = new int[n];
            parts = br.readLine().split(" ");
            for (int i = 0; i < n; i++)
                a[i] = Integer.parseInt(parts[i]);
            int[] gcdPrefix = new int[n];
            int[] gcdSuffix = new int[n];
            for (int i = 0; i < n; i++) {
                gcdPrefix[i] = a[i];
                if (i > 0)
                    gcdPrefix[i] = gcd(gcdPrefix[i], gcdPrefix[i - 1]);
            }
            for (int i = n - 1; i >= 0; i--) {
                gcdSuffix[i] = a[i];
                if (i < n - 1)
                    gcdSuffix[i] = gcd(gcdSuffix[i], gcdSuffix[i + 1]);
            }
            for (int i = 0; i < q; i++) {
                parts = br.readLine().split(" ");
                int left = Integer.parseInt(parts[0]);
                int right = Integer.parseInt(parts[1]);
                left--;
                right--;
                int res = 0;
                if (left > 0)
                    res = gcd(res, gcdPrefix[left - 1]);
                if (right < n - 1)
                    res = gcd(res, gcdSuffix[right + 1]);
                out.println(res);
            }
        }
        out.flush();
    }
}

Answer 2

“几乎不可能进一步优化”？普肖：

1. 添加计算的 GCD 的缓存相邻输入元素，因此它们不需要重新计算。例如，有一个包含input[i] 和input[j] 的GCD 的表。请注意，这不会超过原始输入大小的一半。
2. 计算连续输入对的 GDC（以便您可以利用 #1）

这可以扩展到更大的组，但需要更多空间。

Answer 3

这里的关键是一组数字A 的 GCD 等于A 的任何分区的 GCD 的 GCD。例如，

GCD(16, 8, 24, 15, 20) = GCD(GCD(16, 8), GCD(24, 15, 20))

我会通过构建一些树状结构来利用这一事实。让我们为索引在i 和j 之间的元素集的GCD 写GCD[i, j]。对于大小为n 的给定输入，我将存储：

GCD[1, n]
GCD[1, n/2], GCD[n/2+1, n]
...
GCD[1, 2], GCD[2, 3] ... GCD[n-1, n]

也就是说，在树的每一层，GCD 的数量都会翻倍，而计算它们的集合的大小会减半。请注意，您将以这种方式存储n-1 数字，因此您需要线性额外存储。自下而上计算它们，您将需要执行n-1 GCD 操作作为预处理。

对于查询，您需要将 GCD 组合在一起，以便完全省略两个查询索引。例如，让我们有一个数组A 和n = 8，我们查询(2, 4)。

• 我们不能使用GCD[1, 8]，因为我们需要排除 2 和 4，所以我们在树中更深一层。
• 我们不能使用GCD[1, 4]，但我们可以使用GCD[5, 8]，因为其中没有要排除的索引。上半年，我们需要更深入。
• 我们不能使用GCD[1, 2]，也不能使用GCD[3, 4]，所以我们更深一层。
• 我们只使用元素A[1] 和A[3]。

我们现在需要计算 GCD[5, 8]、A[1] 和 A[3] 的 GCD。对于查询，我们只需要进行 2 次 GCD 计算，而不是简单的 5 次。

一般来说，您将花费O(log n) 时间搜索结构，并且每次查询都需要O(log n) GCD 计算。