leetcode: 质数的最大距离_有一个整数数组nums,返回数组中两个质数在nums中下标的最大距离,这两个质数不一定-CSDN博客

本文链接：https://blog.csdn.net/qq_62985120/article/details/140138215

题目描述

给你一个整数数组 nums。

返回两个（不一定不同的）质数在 nums 中下标的最大距离。

示例 1：

输入： nums = [4,2,9,5,3]

输出： 3

解释： nums[1]、nums[3] 和 nums[4] 是质数。因此答案是 |4 - 1| = 3。

示例 2：

输入： nums = [4,8,2,8]

输出： 0

解释： nums[2] 是质数。因为只有一个质数，所以答案是 |2 - 2| = 0。

提示：
1 <= nums.length <= 3 * 105
1 <= nums[i] <= 100
输入保证 nums 中至少有一个质数。

解法1：

代码

class Solution {
    public int maximumPrimeDifference(int[] nums) {
        int first = 0; // 第一个质数的位置
        int last = nums.length - 1; // 最后一个质数的位置
        
        // 从前往后找到第一个质数
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 1) {
                int j = 2;
                // 判断 nums[i] 是否为质数
                for (; j <= Math.sqrt(nums[i]); j++) {
                    if (nums[i] % j == 0) {
                        break; // 如果能被 j 整除，则 nums[i] 不是质数
                    }
                }
                if (j > Math.sqrt(nums[i])) { // 如果 nums[i] 是质数
                    first = i;
                    break; // 找到第一个质数后退出循环
                }
            }
        }
        
        // 从后往前找到最后一个质数
        for (int i = nums.length - 1; i >= 0; i--) {
            if (nums[i] != 1) {
                int j = 2;
                // 判断 nums[i] 是否为质数
                for (; j <= Math.sqrt(nums[i]); j++) {
                    if (nums[i] % j == 0) {
                        break; // 如果能被 j 整除，则 nums[i] 不是质数
                    }
                }
                if (j > Math.sqrt(nums[i])) { // 如果 nums[i] 是质数
                    last = i;
                    break; // 找到最后一个质数后退出循环
                }
            }
        }
        
        return last - first; // 返回最后一个质数和第一个质数之间的距离
    }
}

思路

初始化：首先初始化两个变量 first 和 last 分别表示第一个质数和最后一个质数的位置。first 初始化为 0，last 初始化为数组的最后一个索引。
寻找第一个质数：

我们从数组的头开始遍历。
对于每个元素，如果它不是 1，我们检查它是否为质数。质数的定义是仅能被 1 和自身整除的数，因此我们从 2 到 sqrt(nums[i]) 检查是否存在除 1 和自身以外的因数。
如果找到一个质数，我们记录它的位置并退出循环。

寻找最后一个质数：

我们从数组的尾开始遍历。
和寻找第一个质数的过程类似，对于每个元素，我们检查它是否为质数。
如果找到一个质数，我们记录它的位置并退出循环。

计算结果：最后，我们返回最后一个质数的位置减去第一个质数的位置，即质数之间的最大距离。

复杂度分析

时间复杂度

寻找第一个质数：

外层循环遍历数组中的每一个元素，时间复杂度为 O(n)，其中 n 是数组的长度。
内层循环检查每个元素是否为质数，时间复杂度为 O(√m)，其中 m 是当前元素的值。
因此，寻找第一个质数的时间复杂度为 O(n * √m)。
寻找最后一个质数：

和寻找第一个质数的分析类似，这部分的时间复杂度也是 O(n * √m)。
综合来看，总的时间复杂度是这两部分的和，即 O(n * √m) + O(n * √m) = O(n * √m)。

空间复杂度

代码中只用了常量级别的额外空间来存储变量 first 和 last，以及一些循环控制变量。因此，空间复杂度为 O(1)。

复杂度总结

时间复杂度：O(n * √m)
空间复杂度：O(1)

解法二：

代码

class Solution {
    public int maximumPrimeDifference(int[] nums) {
        // 创建一个 HashSet 存储小于 100 的所有质数
        Set<Integer> primes = new HashSet<>(Arrays.asList(
            2, 3, 5, 7, 11,
            13, 17, 19, 23, 29,
            31, 37, 41, 43, 47,
            53, 59, 61, 67, 71,
            73, 79, 83, 89, 97
        ));

        int n = nums.length; // 获取数组长度
        int first = -1, ans = 0; // 初始化第一个质数的位置为 -1，最大差值为 0
        for (int i = 0; i < n; i++) { // 遍历数组
            if (primes.contains(nums[i])) { // 检查当前元素是否为质数
                if (first != -1) { // 如果已经找到过第一个质数
                    ans = Math.max(ans, i - first); // 更新最大差值
                } else {
                    first = i; // 记录第一个质数的位置
                }
            }
        }
        return ans; // 返回最大差值
    }
}

思路

存储质数：
使用一个 HashSet 来存储所有小于 100 的质数。因为质数的数量有限，使用 HashSet 可以在常数时间内检查一个数是否为质数。
遍历数组：
初始化数组长度 n 和两个变量 first 和 ans。first 用来记录第一个质数的位置，初始化为 -1，表示还没有找到第一个质数。ans 用来记录最大差值，初始化为 0。
遍历数组 nums，对于每一个元素，检查它是否在质数集合 primes 中。
如果当前元素是质数：
如果 first 已经不为 -1，说明之前已经找到过第一个质数，这时计算当前质数和第一个质数之间的距离，并更新 ans 为这两个质数位置差值的最大值。
如果 first 仍然为 -1，说明这是遇到的第一个质数，记录它的位置到 first。
返回结果：
遍历完成后，返回 ans，即质数之间的最大距离。