LC 2784.Check if Array is Good

题目描述

这是 LeetCode 上的 2784. 检查数组是否是好的 ，难度为简单。

给你一个整数数组 nums ，如果它是数组 base[n] 的一个排列，我们称它是个 好 数组。

base[n] = [1, 2, ..., n - 1, n, n] （换句话说，它是一个长度为 n + 1 且包含 1 到 n - 1 恰好各一次，包含 n 两次的一个数组）。比方说，base[1] = [1, 1] ，base[3] = [1, 2, 3, 3] 。

如果数组是一个好数组，请你返回 true ，否则返回 false 。

注意：数组的排列是这些数字按任意顺序排布后重新得到的数组。

示例 1：

输入：nums = [2, 1, 3]
输出：false
解释：因为数组的最大元素是 3 ，唯一可以构成这个数组的 base[n] 对应的 n = 3 。但是 base[3] 有 4 个元素，但数组 nums 只有 3 个元素，所以无法得到 base[3] = [1, 2, 3, 3] 的排列，所以答案为 false 。

示例 2：

输入：nums = [1, 3, 3, 2]
输出：true
解释：因为数组的最大元素是 3 ，唯一可以构成这个数组的 base[n] 对应的 n = 3 ，可以看出数组是 base[3] = [1, 2, 3, 3] 的一个排列（交换 nums 中第二个和第四个元素）。所以答案为 true 。

示例 3：

输入：nums = [1, 1]
输出：true
解释：因为数组的最大元素是 1 ，唯一可以构成这个数组的 base[n] 对应的 n = 1，可以看出数组是 base[1] = [1, 1] 的一个排列。所以答案为 true 。

示例 4：

输入：nums = [3, 4, 4, 1, 2, 1]
输出：false
解释：因为数组的最大元素是 4 ，唯一可以构成这个数组的 base[n] 对应的 n = 4 。但是 base[n] 有 5 个元素而 nums 有 6 个元素。所以答案为 false 。

提示：

• 1 <= nums.length <= 100
• 1 <= num[i] <= 200

解答

方法一：排序

最容易想到的方法就是排序之后检查每个位置的数是否和序号相等。

class Solution {
    public boolean isGood(int[] nums) {
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 2; ++i) {
            if (i + 1 != nums[i]) {
                return false;
            }
        }
        return nums.length - 1 == nums[nums.length - 1] && nums.length - 1 == nums[nums.length - 2];
    }
}

• 时间复杂度：\(O(n\log n)\)，Java 内部排序算法的时间复杂度为 \(O(n\log n)\)，遍历数组的时间复杂度为\(O(n)\)，所以总的时间复杂度为\(O(n\log n)\)。

• 空间复杂度：\(O(n)\)，Java 内部排序算法的空间复杂度为\(O(n)\)，所以总的空间复杂度为\(O(n)\)。

方法二：模拟

@Source:解法来源

首先，如果一旦有数超过了 n ，直接返回 false。

那么剩下的数都是不超过 n 的。

对于小于 n 的数，出现的次数不能超过一次，对于等于 n 的数，出现的次数不能超过两次。

在这些约束下，对于小于 n 的数不可能有出现零次的（否则某个数的出现次数会超过限制）；同理对于 n 不可能只出现一次（否则某个小于 n 的数会超过一次）。

class Solution {
    public boolean isGood(int[] nums) {
        int n = nums.length - 1;
        int[] hash = new int[n + 1];
        for(int i : nums) {
            if(i > n || (i < n && hash[i] > 0)) {
                return false;
            }
            ++hash[i];
        }
        return hash[n] == 2;
    }
}

• 时间复杂度：\(O(n)\)，遍历一次数组，时间复杂度为 nums 的长度 n 。

• 空间复杂度：\(O(n)\)，用于存储对应 nums 的出现次数的 hash 数组的长度和 nums 的长度成正比，所以空间复杂度为\(O(n)\)。

每题一图