Arrays 在数组中查找多数元素的候选者

我不是问如何在数组中找到多数元素，这里已经详细讨论了这一点

我的问题如下：

有一个数组

arr[1…2n]

，该数组的大多数元素是

maj

，现在我将使用以下规则删除

arr

中的元素

如果

arr[i]==arr[i+1]

，则删除

arr[i]

，i=1,3,5，…，2n-1； 如果

arr[i]！=arr[i+1]

，删除

arr[i]

和

arr[i+1]

，i=1,3,5，…，2n-1

然后我们可以得到一个新的数组

new\u-arr

，并且

new\u-arr

的多数元素的候选元素是

new\u-maj

，

---

是否有任何证据证明

new_maj==maj

？

定义

N=2n

。数组包含

N个
元素

将
M
定义为数组中出现
maj
的次数。“多数元素”的定义是
M>N/2

现在将数组分成几对
p[1]。。。p[n]
。将
q0
定义为包含
maj
零实例的对数。将
q1
定义为仅包含一个
maj
实例的对数。将
q2
定义为正好包含两个
maj
实例的对数

然后
N=2q0+2q1+2q2
和
M=q1+2q2

替换为定义多数元素的不等式，并简化：

        M > N / 2
q1 + 2 q2 > (2 q0 + 2 q1 + 2 q2) / 2
q1 + 2 q2 > q0 + q1 + q2
     2 q2 > q0 + q2
       q2 > q0

因此，包含两个
maj
实例的对的数量超过了包含零个
maj
实例的对的数量

现在定义
M'
为运行算法后新数组中出现
maj
的次数。该算法为每个
q1
对删除一个
maj
，为每个
q2
对删除一个
maj
。所以
M'=M-q1-q2

定义
N'
为算法生成的新数组的大小。该算法为每个
q1
对删除两个元素，为每个
q2
对删除一个元素

但是我们不知道算法为每个
q0
对删除了多少元素。一些
q0
对包含两个不同的元素，算法会同时删除这两个元素。但是其他
q0
对包含相同的（非
maj
）元素，并且该算法只删除一个

一个极端是所有
q0
对都被完全删除。在这种情况下，算法删除
2个q0
元素，因此

N - 2 q1 - q2 - 2 q0 ≤ N'

N - 2 q1 - q2 - q0 ≥ N'

另一个极端是从每个
q0
对中只删除一个元素。在这种情况下，算法删除
q0
元素，因此

N - 2 q1 - q2 - 2 q0 ≤ N'

N - 2 q1 - q2 - q0 ≥ N'

让我们回到“多数元素”的定义，做一些代数：

          M > N / 2
M - q1 - q2 > N / 2 - q1 - q2
M - q1 - q2 > (N - 2 q1 - 2 q2) / 2
M - q1 - q2 > (N - 2 q1 - q2 - q2) / 2

左手边是
M'

M' > (N - 2 q1 - q2 - q2) / 2

我们能把右边变成
N'/2
吗？首先，将两侧乘以2：

2 M' > N - 2 q1 - q2 - q2

回想一下，我们证明了
q2>q0
。所以

2 M' > N - 2 q1 - q2 - q2 > N - 2 q1 - q2 - q0

而且，由于我们推导出
N-2q1-q2-q0≥ N'

2 M' > N - 2 q1 - q2 - q0 ≥ N'

所以

因此，
maj
在新数组中出现的次数足够多，可以成为新数组的主要元素。QED.
是的，有证据

我们只对元素对
a[i]，a[i+1]
，
i
奇数感兴趣。如果a[i]=a[i+1]
，我们称这样的一对为“好”。其他双是“坏的”。与多数候选元素相等的元素是“groovy”。好的groovy元素对就是groovy元素对

关于好的配对，一个简单的事实是至少有一半的好配对是groovy的。假设不是这样；然后，在好的对中，只有不到一半的元素是groovy，而在坏的对中，不超过一半的元素是groovy。总的来说，只有不到一半的元素是groovy。这是一个矛盾

因此，我们已经确定，至少有一半的好配对是groovy

现在消除所有坏的对。所有元素中至少有一半是groovy（因为只剩下好的对，其中至少有一半是groovy）

现在从好的对中删除所有其他元素。仍然至少有一半的元素是groovy（因为每个元素的数量只是减半）

证据到此结束。
以下是我的证据变体：

考虑对arr[i]和arr[i+1]的4种情况（反之亦然，对的顺序并不重要），i是奇数。让maj为主要元素，min为次要元素：

majmaj-将这些对的数量设为a
majmin-将此类对的数量设为b
min1min2-将此类对的数量设为c，min1！=min2
min1min1-将这些对的数量设为d
a、 b、c、d都大于等于0

案例1对主要元素的原始和| maj |贡献2，并将主要元素的最终和| maj | |’（在执行算法后）减少1

案例2为所有次要元素的原始总和| maj |贡献1，为| min |贡献1，并将| maj |减少1，将| min |减少1

案例3为| min |贡献2，将| min |减少2

案例4为| min |贡献2，将| min |减少1

因此，原始数组arr[]中主要元素的总数为：

|maj| = 2a + b

而所有次要元素的数量为：

|min| = b + 2c + 2d

|min|' = |min| - b - 2c - d

自| maj |>min |

2a + b > b + 2c + 2d
    2a > 2c + 2d
     a > c + d

运行该算法后，主要元素的新数量如下所示：

|maj|' = |maj| - a - b

新的次要元素数量为：

|min| = b + 2c + 2d

|min|' = |min| - b - 2c - d

我们得到：

|maj|' = 2a + b - a - b           = a
|min|' = b + 2c + 2d - b - 2c - d = d

因为我们从上面知道c+d=0，所以我们有

a > c + d =>
a > d =>
|maj|' > |min|'

因此，maj仍然是