Leedcode刷题第三天_摩尔投票法

一.摩尔投票法

思路：

现在多军对峙，假设阵营A士兵人数比其他方的人数都多，阵营A士兵能以一杀一，那么只要阵营A士兵不杀自己人（一样的数字），去杀不同阵营的人（不同的数字），那么最后剩下的那些士兵，就是阵营A的士兵（众数）。

应用：

求多数元素，即一个数组中，求出现多次的元素；

1. 如果至多选一个代表，那么他的票数要至少超过1/2的票数

（选出出现的次数至少超过length/2次的数字，则该数字只有一个）
2. 如果至多选两个代表，票数至少要超过1/3的票数

（选出出现的次数至少超过length/3次的数字，则该数字至多有2个）
2. 如果至多选m个代表，那他们的票数至少要超过1/(m+1)

（选出出现的次数至少超过length/m次的数字，则该数字至多有m-1个）

二.例题

ps:例题代码看不懂就先看3.代码理解解析

1.多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊n/2⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：

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

示例 2：

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

//守擂思想 ：守擂守到最后的就是众数
class Solution {
public:
    int majorityElement(vector<int>& nums) {
	 
    	int maj=nums[0]; //开始时，选取首元素为擂主（众数） 
        int count=1; //count用来给众数计数，就计数1（擂主这一边有一个人）

        for(int i=1; i<nums.size(); i++)//首元素已经选了，那就从第二个开始比较吧
	    {
           //下边是摩尔投票的思想
           if(count==0) maj=nums[i];//发现没有擂主，随便抓下面一个做擂主 
           if(nums[i]==maj) count++;//遇见和擂主是一个帮派的，那人就上去擂主那边一起守擂 
           else count--; //遇见是敌方帮派，就派擂主这边一个人和他同归于尽（擂主帮派-1） 
	    }	
        return maj;
    }
};

2.找出数组中出现次数超过⌊n/3⌋ 的数，可以设置两个临时变量保存数组元素

#include<iostream>
#include<vector>
#include<algorithm> 
using namespace std;

int main()
{
	int b[5]={1,1,2,2,3};
	int result_list_index = 0;
    vector<int> array(b,b+5); //从数组中获得初值
	
	int result_list[1000]={0};
    
	if(array.size() == 0) cout<<"null"<<endl;
    int maj1 = array[0],maj2 = array[0];
    int count1 = 0,count2 = 0;
    int len = array.size();
    for(int i = 0;i<len;i++) {
    	if(array[i] == maj1) count1++;
    	else if(array[i] == maj2) count2++;
    	else if(count1<=0) {
    		count1 = 1;
    		maj1 = array[i];
    	}
		else if(count2<=0) {
    		count2 = 1;
    		maj2 = array[i];
    	}
		else {
    		--count1;
    		--count2;
    	}
    }
    count1 = count2 =0;
    for(int i =0;i<len;i++) 
	{
    	if(array[i] == maj1) count1++;
    	if(array[i] == maj2) count2++;
    }
    
    if(count1>len/3)
    	 result_list[result_list_index++] = maj1;
    if(count2>len/3)
    	 result_list[result_list_index] = maj2;
    	 
    for(int i=0;i<=result_list_index;i++)
    	cout<<result_list[i]<<"	";

	return 0;
} 

3.代码理解解析(来自知乎)

重点：

首先请考虑最基本的摩尔投票问题，找出一组数字序列中出现次数大于总数1/2的数字（并且假设这个数字一定存在）。显然这个数字只可能有一个。 摩尔投票算法是基于这个事实：每次从序列里选择两个不相同的数字删除掉（或称为“抵消”），最后剩下一个数字或几个相同的数字，就是出现次数大于总数一半的那个。请首先认同这个事实，这里不证明了~

我们的目标就是：删除，删除，删除。删到不能删除为止。

实现的算法从第一个数开始扫描整个数组，有两个变量(参考第一答题者的变量名)major和count。其实这两个变量想表达的是一个“隐形的数组”array，array存储的是“当前暂时无法删除的数字”，我们先不要管major和count，只考虑这个array，同时再维护一个结果数组result，result里面存储的是每次删除一对元素之后的当前结果。为了方便理解举一个示例

输入：{1,2,1,3,1,1,2,1,5}

• 从第一个数字1开始，我们想要把它和一个不是1的数字一起从数组里抵消掉，但是目前我们只扫描了一个1，所以暂时无法抵消它，把它加入到array，array变成了{1}，result由于没有抵消任何元素所以还是原数组{1,2,1,3,1,1,2,1,5}。
• 然后继续扫描第二个数，是2，我们可以把它和一个不是2的数字抵消掉了，因为我们之前扫描到一个1，所以array变成了{},result变成了{1,3,1,1,2,1,5}
• 继续扫描第三个数1，无法抵消，于是array变成了{1},result还是{1,3,1,1,2,1,5};
• 接下来扫描到3,可以将3和array数组里面的1抵消,于是array变成了{},result变成了{1,1,2,1,5}
• 接下来扫描到1，此时array为空，所以无法抵消这个1，array变成了{1},result还是{1,1,2,1,5}
• 接下来扫描到1，此时虽然array不为空，但是array里也是1，所以还是无法抵消，把它也加入这个array,于是array变成了{1,1}（其实到这我们可以发现，array里面只可能同时存在一种数，因为只有array为空或当前扫描到的数和array里的数字相同时才把这个数字放入array）,result还是{1,1,2,1,5}
• 接下来扫描到2，把它和一个1抵消掉，至于抵消哪一个1，无所谓，array变成了{1},result是{1,1,5}
• 接下来扫描到1，不能抵消，array变成了{1,1}，result{1,1,5}
• 接下来扫描到5，可以将5和一个1抵消，array变成了{1},result变成了{1}

至此扫描完成了数组里的所有数，result里剩了1，所以1就是大于一半的数组。

再回顾一下这个过程，其实就是删除（抵消）了（1，2），（1，3），（1，5）剩下了一个1。

除去冗余关系：实际代码中没有array，也没有result，因为我们不需要。由于前面提到array里只可能同时存储一种数字，所以我们用major来表示当前array里存储的数，count表示array的长度,即目前暂时无法删除的元素个数，最后扫描完所有的数字，array和result变成一样了，都表示“最后还是无法删除的数字”。

---

我们再根据只有两个变量的实际代码理一遍：

major 初始化随便一个数，即上面array数组中的数字（众数）

count 初始化为0，即上面array数组中的元素个数（众数出现次数）

输入：{1,2,1,3,1,1,2,1,5}

• 扫描到1，count是0（没有元素可以和当前的1抵消），于是major = 1，count = 1（此时有1个1无法被抵消）
• 扫描到2，它不等于major，于是可以抵消掉一个major => count -= 1，此时count = 0,其实可以理解为扫到的元素都抵消完了，这里可以暂时不改变major的值
• 扫描到1，它等于major，于是count += 1 => count = 1
• 扫描到3，它不等于major，可以抵消一个major => count -= 1 => count = 0，此时又抵消完了(实际的直觉告诉我们，扫描完前四个数，1和2抵消了，1和3抵消了)
• 扫描到1，它等于major，于是count += 1 => count = 1
• 扫描到1，他等于major，无法抵消 => count += 1 => count = 2 (扫描完前六个数，剩两个1无法抵消)
• 扫描到2，它不等于major，可以抵消一个major => count -= 1 => count = 1,此时还剩1个1没有被抵消
• 扫描到1，它等于major，无法抵消 => count += 1 => count = 2
• 扫描到5，它不等于major，可以抵消一个major => count -= 1 => count = 1

至此扫描完成，还剩1个1没有被抵消掉，它就是我们要找的数。