蓝桥杯真题——近似gcd（很离谱！！！）

小蓝有一个长度为 n 的数组 A=(a1,a2,⋯,an), 数组的子数组被定义为从原数组中选出连续的一个或多个元素组成的数组。数组的最大公约数指的是数组中所有元素的最大公约数。如果最多更改数组中的一个元素之后, 数组的最大公约数为 g, 那么称 g 为这个数组的近似 GCD。一个数组的近似 GCD 可能有多种取值。

具体的, 判断 g 是否为一个子数组的近似 GCD 如下:

如果这个子数组的最大公约数就是 g, 那么说明 g 是其近似 GCD。
在修改这个子数组中的一个元素之后 (可以改成想要的任何值), 子数组的最大公约数为 g, 那么说明 g 是这个子数组的近似 GCD。

小蓝想知道, 数组 A 有多少个长度大于等于 2 的子数组满足近似 GCD 的值为 g 。

输入格式

输入的第一行包含两个整数 n,g 用一个空格分隔, 分别表示数组 A 的长度和 g 的值。

第二行包含 n 个整数 a1,a2,⋯,an 相邻两个整数之间用一个空格分隔。

输出格式

输出一行包含一个整数表示数组 A 有多少个长度大于等于 2 的子数组的近似 GCD 的值为 gg 。

样例输入

复制代码

5 3
1 3 6 4 10

样例输出

复制代码

样例说明

满足条件的子数组有 5 个:

看到这里是不是以为自己也是天才了

Java写法：

java 复制代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 读取输入：数组长度n和目标近似GCD值g
        int n = scanner.nextInt();
        int g = scanner.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
        }

        // 预处理：生成bad数组，标记每个元素是否能被g整除
        // bad[i] = 1 表示该元素需要修改，否则为0
        int[] bad = new int[n];
        for (int i = 0; i < n; i++) {
            bad[i] = (a[i] % g != 0) ? 1 : 0;
        }

        int left = 0;       // 滑动窗口左边界
        int currentSum = 0; // 当前窗口内bad值的总和（即需要修改的元素数量）
        long result = 0;    // 统计符合条件的子数组总数

        // 滑动窗口遍历数组
        for (int right = 0; right < n; right++) {
            currentSum += bad[right]; // 将右指针指向的元素加入窗口

            // 当窗口内bad值超过1时，右移左指针直到满足条件
            while (currentSum > 1) {
                currentSum -= bad[left];
                left++;
            }

            // 计算以当前right结尾的符合条件的子数组数量
            // 窗口范围是[left, right]，需要长度>=2，因此有效子数组数量为 right - left
            // 例如：窗口长度为3（right - left +1 =3）时，有2个长度>=2的子数组以right结尾
            result += Math.max(0, right - left);
        }

        // 输出结果
        System.out.println(result);
        scanner.close();
    }
}

AC情况

不是哥们儿

沟槽的蓝桥杯还是没有发现吗，我这个方法连基本的题目都没满足。

我的答案连续吗，沟槽的测试用例居然还是过了简直逆天。

解法二：维护滑动窗口

滑动窗口维护 ：当遇到无法被g整除的元素时，将左边界 left 移到上一个bad元素的下一个位置，确保窗口内最多一个bad元素。
结果累加 ：窗口内所有以 right 结尾的子数组数量为 right - left（因为长度≥2的子数组有 right - left 个）。

Java写法：

java 复制代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        long g = scanner.nextLong();
        long result = 0;

        int lastBadPos = -1; // 上一个无法被g整除的元素位置
        int left = 0;        // 滑动窗口左边界

        // 1 3 6 4 10
        for (int right = 0; right < n; right++) {
            long num = scanner.nextLong();
            // 若当前元素无法被g整除，更新窗口左边界
            if (num % g != 0) {
                left = lastBadPos + 1; // 左边界移到上一个bad元素的下一位
                lastBadPos = right;    // 更新最后一个bad元素的位置
            }

            // 计算以right结尾的合法子数组数量
            // 子数组长度至少为2，即区间长度 >=2 (right - left >=1)
            if (right - left >= 1) {
                result += right - left;
            }
        }

        System.out.println(result);
        scanner.close();
    }
}

AC情况

但是，这个方法相比于第一个要更合理，但是它仍然给不出你完全契合测试用例的解释，只能勉强解释通，由于篇幅限制我就不再赘述，大家可以根据代码推一推。

总结

所以我说这个沟槽的蓝桥杯的这道题太离谱了铁铁，我根本不能接受。因为它真的找不到一个完美的解释，但是又可以逃脱测试用例的安排，通关。