1207. Unique Number of Occurrences

Given an array of integers arr, return true if the number of occurrences of each value in the array is unique or false otherwise.

 

Example 1:

Input: arr = [1,2,2,1,1,3]
Output: true
Explanation: The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.
Example 2:

Input: arr = [1,2]
Output: false
Example 3:

Input: arr = [-3,0,1,-3,1,1,1,-3,10,0]
Output: true
 

Constraints:

1 <= arr.length <= 1000
-1000 <= arr[i] <= 1000

给定一个整数数组 arr，如果数组中每个值的出现次数都是独一无二的，则返回 true，否则返回 false。

示例 1：

输入：arr = [1,2,2,1,1,3]
输出：true
解释：数值 1 出现了 3 次，数值 2 出现了 2 次，数值 3 只出现了 1 次，每个数值出现的次数都是独一无二的。

示例 2：

输入：arr = [1,2]
输出：false

示例 3：

输入：arr = [-3,0,1,-3,1,1,1,-3,10,0]
输出：true

提示：

1 <= arr.length <= 1000
-1000 <= arr[i] <= 1000

以下是 Java 代码实现：

class Solution {
    public boolean uniqueOccurrences(int[] arr) {
        Map<Integer, Integer> map = new HashMap<>(); // 定义一个哈希表来记录每个数值出现的次数
        for (int num : arr) {
            map.put(num, map.getOrDefault(num, 0) + 1); // 统计每个数值出现的次数
        }
        Set<Integer> set = new HashSet<>(); // 定义一个哈希集合来记录出现次数是否重复
        for (int count : map.values()) {
            if (set.contains(count)) { // 如果出现次数重复，返回false
                return false;
            }
            set.add(count); // 记录出现次数
        }
        return true;
    }
}
这段代码的思路比较简单，遍历数组 arr，使用哈希表统计每个数值出现的次数，并使用哈希集合记录出现次数是否重复，如果出现次数重复，返回false，否则返回true。代码中增加了中文注释，以便于理解代码中各个部分的功能。

best answer

这段代码是判断数组中每个数值的出现次数是否独一无二的，思路与之前的代码略有不同。同样使用哈希表统计每个数值出现的次数，但是不使用哈希集合记录出现次数是否重复，而是使用数组 cCount 记录出现次数出现的次数，也就是出现次数为 i 的数值有几个。具体实现如下：

先找出数组中的最大值和最小值，判断数组中的数值是否全是正数，如果是，则使用长度为 max+1 的数组 count 统计每个数值出现的次数，如果不是，则使用长度为 max-min+1 的数组 count 统计每个数值出现的次数。

定义一个变量 cM 来记录出现次数的最大值，遍历数组，统计每个数值出现的次数，并更新 cM。

定义一个长度为 cM+1 的数组 cCount，遍历 count 数组，将出现次数出现的次数存入 cCount 数组中。

遍历 cCount 数组，如果有出现次数出现的次数不等于0或1，则返回false，否则返回true。

代码中增加了中文注释，以便于理解代码中各个部分的功能。

以下是 Java 代码实现：

class Solution {
    public boolean uniqueOccurrences(int[] arr) {
        int min=1000;
        int max=-1000;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        if(min>=0){
            int count[]=new int[max+1];
            int cM=0;
            for(int i=0;i<arr.length;i++){
                count[arr[i]]++;
                if(count[arr[i]]>cM){
                    cM=count[arr[i]];
                }
            }
            
            int cCount[]=new int[cM+1];
       
         
            for(int i=0;i<count.length;i++){
                if(count[i]>0){
                    if(cCount[count[i]]==1) return false;
                    cCount[count[i]]++;
                }
            }
            return true;

        }
        else{
            int len=max+(-1)*min+1;
            int count[]=new int[len];
            for(int i=0;i<arr.length;i++){
                count[arr[i]+(-1)*min]++;
            }
            int cM=0;
            for(int i=0;i<arr.length;i++){
                if(count[arr[i]+(-1)*min]>cM){
                    cM++;
                }
            }
            int cCount[]=new int[cM+1];
            for(int i=0;i<count.length;i++){
                if(count[i]>0){
                    cCount[count[i]]++;
                }
            }
            int t=0;
            for(int i=0;i<cCount.length;i++){
                if(cCount[i]!=0 && cCount[i]!=1){
                    t++;
                }
            }
            if(t==0){
                return true;
            }
            return false;

        }
        
    }
}