独一无二的出现次数：LeetCode题解与详细解析

2023-11-12 00:06:38

题目

给你一个整数数组 arr 和一个整数 k 。如果对于每对不同的索引 i 和 j ，都有 arr[i] * arr[j] 除以 k 的余数 不唯一 ，那么返回 true；否则，返回 false 。

示例 1：

输入：arr = [3,1,7,11], k = 3
输出：true
解释：
arr[0] * arr[1] = 3 * 1 = 3
arr[0] * arr[2] = 3 * 7 = 21
arr[1] * arr[2] = 1 * 7 = 7
arr[0] * arr[3] = 3 * 11 = 33
arr[1] * arr[3] = 1 * 11 = 11
arr[2] * arr[3] = 7 * 11 = 77
由于存在多对索引 i 和 j 使得 arr[i] * arr[j] 除以 k 的余数不唯一（分别是 (0, 1) 和 (1, 2)），所以返回 true。

示例 2：

输入：arr = [1,2,3,4], k = 2
输出：false
解释：
arr[0] * arr[1] = 1 * 2 = 2
arr[0] * arr[2] = 1 * 3 = 3
arr[0] * arr[3] = 1 * 4 = 4
arr[1] * arr[2] = 2 * 3 = 6
arr[1] * arr[3] = 2 * 4 = 8
arr[2] * arr[3] = 3 * 4 = 12
由于不存在任何一对索引 i 和 j 使得 arr[i] * arr[j] 除以 k 的余数不唯一，所以返回 false。

算法解析

这道题考察了数组和除法余数的操作。我们可以通过以下步骤来解决这个问题：

首先，我们需要计算出数组中每个元素除以 k 的余数，并将其存储在一个哈希表中。
然后，我们需要遍历数组中的每个元素，并计算出其与其他所有元素的乘积除以 k 的余数。
如果存在一对元素的乘积除以 k 的余数与其他任何一对元素的乘积除以 k 的余数相同，那么我们就返回 true。
否则，我们就返回 false。

时间复杂度

该算法的时间复杂度为 O(n^2)，其中 n 是数组 arr 的长度。这是因为我们需要遍历数组中的每个元素，并计算其与其他所有元素的乘积除以 k 的余数。

代码实现

def uniqueOccurrences(arr, k):
    """
    :type arr: List[int]
    :type k: int
    :rtype: bool
    """
    # 计算每个元素除以 k 的余数
    remainder_dict = {}
    for num in arr:
        remainder = num % k
        if remainder not in remainder_dict:
            remainder_dict[remainder] = 0
        remainder_dict[remainder] += 1

    # 检查是否存在一对元素的乘积除以 k 的余数与其他任何一对元素的乘积除以 k 的余数相同
    for remainder1 in remainder_dict:
        for remainder2 in remainder_dict:
            if remainder1 != remainder2 and remainder1 * remainder2 % k == 0:
                return True

    # 如果不存在，则返回 false
    return False

class Solution {
    public boolean uniqueOccurrences(int[] arr, int k) {
        // 计算每个元素除以 k 的余数
        Map<Integer, Integer> remainderMap = new HashMap<>();
        for (int num : arr) {
            int remainder = num % k;
            remainderMap.put(remainder, remainderMap.getOrDefault(remainder, 0) + 1);
        }

        // 检查是否存在一对元素的乘积除以 k 的余数与其他任何一对元素的乘积除以 k 的余数相同
        for (Integer remainder1 : remainderMap.keySet()) {
            for (Integer remainder2 : remainderMap.keySet()) {
                if (remainder1 != remainder2 && remainder1 * remainder2 % k == 0) {
                    return true;
                }
            }
        }

        // 如果不存在，则返回 false
        return false;
    }
}

class Solution {
public:
    bool uniqueOccurrences(vector<int>& arr, int k) {
        // 计算每个元素除以 k 的余数
        unordered_map<int, int> remainderMap;
        for (int num : arr) {
            int remainder = num % k;
            remainderMap[remainder]++;
        }

        // 检查是否存在一对元素的乘积除以 k 的余数与其他任何一对元素的乘积除以 k 的余数相同
        for (auto it1 = remainderMap.begin(); it1 != remainderMap.end(); it1++) {
            for (auto it2 = remainderMap.begin(); it2 != remainderMap.end(); it2++) {
                if (it1 != it2 && it1->first * it2->first % k == 0) {
                    return true;
                }
            }
        }

        // 如果不存在，则返回 false
        return false;
    }
};

/**
 * @param {number[]} arr
 * @param {number} k
 * @return {boolean}
 */
const uniqueOccurrences = (arr, k) => {
  // 计算每个元素除以 k 的余数
  const remainderMap = {};
  for (let num of arr) {
    const remainder = num % k;
    if (!remainderMap[remainder]) {
      remainderMap[remainder] = 0;
    }
    remainderMap[remainder]++;
  }

  // 检查是否存在一对元素的乘积除以 k 的余数与其他任何一对元素的乘积除以 k 的余数相同
  for (let remainder1 in remainderMap) {
    for (let remainder2 in remainderMap) {
      if (remainder1 != remainder2 && remainder1 * remainder2 % k === 0) {
        return true;
      }
    }
  }

  // 如果不存在，则返回 false
  return false;
};