1207. 独一无二的出现次数 的三种解法

  给你一个整数数组 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-number-of-occurrences
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

提示：

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

  根据提示，这种输入数据有限制的情况，首先想到了 " 桶 "，虽然解法有三种，不过都是基于桶的。
  因为输入数据范围 -1000 <= arr[i] <= 1000，所以得加1000，全部转为非负数，用来做桶数组的下标。

解法1

  申请一个与输入数组arr相同大小的数组arr_tmp,原来保存加1000偏移后的坐标。
  （当然要是为了省一丢丢内存，也可以直接用arr来存，不过这就改变原始数据了，做题可以，实际操作不推荐。）
  在一个很大的桶里放好了统计出来的次数，如何找出两个相同的数呢，可以暴力双循环:

for(int i=0;i<2000;i++){
        for(int j=i+1;j<2001;j++){...

  但是，多数情况下，桶的很多位置是不会装数据的，这种办法会无条件遍历有数据和没数据的位置，效率不高，有没有办法知道哪些位置存有数据呢，还是有的，这就是arr_tmp保留坐标的原因。于是双循环变成了：

 for(int i=0;i<arrSize-1;i++){
        for(int j=i+1;j<arrSize;j++){...

效率提高不少。但要注意arr_tmp中可能会有重复的坐标，所以加上 arr_tmp[j]!=arr_tmp[i]。

bool uniqueOccurrences(int* arr, int arrSize){
    int times[2001]={0};

    int* arr_tmp;
    arr_tmp = (int *)malloc(arrSize * sizeof(int));
    memset(arr_tmp, 0,arrSize * sizeof(int));  

    for(int i=0;i<arrSize;i++){    
        arr_tmp[i] = arr[i] + 1000;//保存偏移后的坐标
        times[ arr_tmp[i] ]++;
    }
    for(int i=0;i<arrSize-1;i++){
        for(int j=i+1;j<arrSize;j++){
            if(arr_tmp[j]!=arr_tmp[i] && times[arr_tmp[i]]==times[arr_tmp[j]] ){
                return false;
            }
        }
    }
    return true;
}

解法2

  老规矩，先用桶装次数；某数第一次出现就在相应位置设置为true，如果下次相同位置为true那么肯定是重复出现了。这比解法1条理清晰得多，更易理解。

bool uniqueOccurrences(int* arr, int arrSize){
    int times[2001]={0};
    bool freqc[1001]={false};
    bool res=true;
    //统计每个数出现的次数
    for(int i=0;i<arrSize;i++){  
        times[ arr[i] + 1000 ]++;
    }
    
    for(int i=0;i<2001;i++){
        if( times[i] > 0){
            if(freqc[ times[i] ] == false){//次数第一次出现就在相应位置设置为true
                freqc[ times[i] ] = true;
            }else{//如果为true，那么之前出现过，可以收工了
                res = false;
                break;                
            }
        }   
    }  
    return res;
}

解法3

  这办法一看挺唬人的，也的确懵逼了一阵。。。

bool uniqueOccurrences(int* arr, int arrSize){
    int times[2001]={0};
    int freqc[1001]={0};
    bool res=true;

    for(int i=0;i<arrSize;i++){
        int tmp= arr[i] + 1000;
        freqc[ times[tmp] ]--;  
        times[ tmp ]++;//统计每个数出现的次数              
        freqc[ times[tmp] ]++;      
    }
    for(int i=1;i<1001;i++){
        if(freqc[ i ]>1){
            res = false;
            break;
        }                      
    }  
    return res;
}

  最不懂的就是： freqc[ times[tmp] ]- - 不理解为什么要自减。然后debug了一下，看数据的变化：

    for(int i=0;i<arrSize;i++){
        int tmp= arr[i] + 1000;
        freqc[ times[tmp] ]--;//不懂
        printf("i=%d; freqc[%d]= %3d; ",i,times[tmp],freqc[ times[tmp] ]);
        times[ tmp ]++;
        freqc[ times[tmp] ]++;
        printf("freqc[%d]= %3d \n",times[tmp],freqc[ times[tmp] ]);
    }

以[2,2,2,1,4,4]为例，运行结果如下：

分析：
  freqc[0]表示出现0次的数，没有意义；
  freqc[3] = 1 表示有1数出现了3次；
  freqc[1] = 1 表示有1数出现了1次；
  freqc[2] = 1 表示有1数出现了2次；

  freqc[2] = 3 表示有3数出现了2次；

  出现3次的数，必定先出现1次，再出现2次,(这不废话吗…),即：出现1次时，freqc[1]会加1，出现2次时，freqc[2]会加1，但只需要最终的freqc[3]加1就够了.
  所以，那些中间量必须抹掉，这就是 freqc[ times[tmp] ]- - 的作用。出现2的时候抹掉1，出现3的时候抹掉2。

改进：

bool uniqueOccurrences(int* arr, int arrSize){
    int times[2001]={0};
    int freqc[1001]={0};
    bool res=true;

    for(int i=0;i<arrSize;i++){
        freqc[ times[arr[i] + 1000]++ ]--;        
        freqc[ times[arr[i] + 1000]   ]++;
	}
    for(int i=1;i<1001;i++){//统计次数的频率
        if(freqc[ i ]>1){
            res = false;
            break;
        }                      
    }  
    return res;
}

  改进后的法3在大部分case中表现很好，某些case下效果特别好：