LeetCode961 重复 N 次的元素

问题： 重复 N 次的元素

在大小为 2N 的数组 A 中有 N+1 个不同的元素，其中有一个元素重复了 N 次。

返回重复了 N 次的那个元素。

示例 1：

输入：[1,2,3,3]
输出：3

示例 2：

输入：[2,1,2,5,3,2]
输出：2

示例 3：

输入：[5,1,5,2,5,3,5,4]
输出：5

提示：

1. 4 <= A.length <= 10000
2. 0 <= A[i] < 10000
3. A.length 为偶数

链接：https://leetcode-cn.com/contest/weekly-contest-116/problems/n-repeated-element-in-size-2n-array/

分析：

0.AC做法，将数据排序，统计每个元素的个数，一旦某一个是N，返回这个数字。

1.2N个元素中有N+1个不同的元素，且一个元素重复了N次，则这个重复了N次的必定是唯一众数，且除非是最大值或者最小值，否则也必定是中数。

比赛期间尝试直接返回中位值，不过失败了，没继续深入，现在想来，只有是最大值或者最小值的时候才会失败，完全可以只统计最大值个数，最小值个数，如果有一个是N，返回，否则返回排序后中间的那个数字。

AC Code：

 class Solution {
 public:
 int repeatedNTimes(vector<int>& A) {
         if (A.size() == )
         {
             return A[];
         }
         int ret = ;
         sort(A.begin(), A.end());
         //ret = A[A.size() / 2];
         int num = ;
         ret = A[];
         for (unsigned int i = ; i < A.size(); i++)
         {
             if (A[i] != ret)
             {
                 ret = A[i];
                 num = ;
             }
             else
             {
                 num++;
                 if (num == A.size() / )
                 {
                     return ret;
                 }
             }
         }
         return ret;
     }
 };

赛后AC code

class Solution {
public:
int repeatedNTimes(vector<int>& A) {
        if (A.size() == )
        {
            return A[];
        }
        int ret = ;
        sort(A.begin(), A.end());

        int num = A[];
        int times = ;
        for (int i = ; i < A.size(); i++)
        {
            if (num != A[i])
            {
                if (times == A.size() / )
                {
                    return A[];
                }
                break;
            }
            else
            {
                times++;
            }
        }
        num = A[A.size() - ];
        times = ;
        for (int i = A.size()-;i>= ;i--)
        {
            if (num != A[i])
            {
                if (times == A.size() / )
                {
                    return num;
                }
                break;
            }
            else
            {
                times++;
            }
        }
        ret = A[A.size() / ];

        return ret;
    }
};

其他：

1.简单的题，随便就过了，如果对时间有要求的话，可能就得用第二种方法才能过了。

不考虑太多，统计每个元素个数就够了。

2.第一code：

 class Solution:
     def repeatedNTimes(self, A):
         """
         :type A: List[int]
         :rtype: int
         """
         n = len(A)//
         l = dict()
         for e in A:
             if e in l:
                 l[e] +=
             else:
                 l[e] =
         for e in l:
             if l[e] == n:
                 return e

统计个数找个数是N的，可能都没怎么多想吧

第二code：

 class Solution(object):
     def repeatedNTimes(self, A):
         """
         :type A: List[int]
         :rtype: int
         """
         d = set()
         for num in A:
             if num not in d:
                 d.add(num)
             else:
                 return num

感觉更有意思一点，2N个元素，N+1个不同，其中一个还是有N个元素的，那么其他的都是只有一个元素，那么完全可以更快：答案必定是A[A.size()/2]和A[A.size()/2-1]中的一个，如果两者相同，即为结果，否则如果A[A.size()/2-1]==A[A.size()/2-2]，是答案，否则A[A.size()/2]是答案。