CCF 202012-2 期末预测之最佳阈值 C++

暴力解决只有70分：

#include <iostream>
using namespace std;
int main()
{
	int m,count=0;
	cin >> m;
	int a[m],b[m];
	
	for(int i=0;i<m;i++)
	{
		cin >> a[i] >> b[i];
	}
	int r=a[0];
	int max=0;
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<m;j++)
		{
			if((a[j]>=a[i]&&b[j]==1)||(a[j]<a[i]&&b[j]==0))
			     count++;
		}
		if(count>max||(count==max&&a[i]>r))
		{
			r=a[i];
			max=count;
		}
		count=0;
	}
	
	cout << r << endl;	
	return 0;
}

100代码学习一下

100代码：
优化的关键：
用暴力二重循环，会重复很多不必要的遍历和比较操作（遍历阈值时，比如阈值3结束查询，阈值4开始查询，这时比3和4都小的数，以及比3和4都大的数，预测结果是不会变的，但暴力二重循环还是会再全部查询一遍，徒增运行时间！），所以我们有必要进行优化。
为此，首先要把数值对根据第一列的键值进行排序，让第一列递增，这样才能够利用前一个和后一个数的结果，减少重复检测。
使用sort进行排序，对每个键值只进行一次统计正确数，如果后面几个键值重复，则直接跳过。
定义一组变量int count=0,max=0,count1=0,count2=0,count_0=0,count_1=0;
其中，count是当前键值的正确数，max是正确数最多的次数，count1是上一个不重复键值的小于它且成绩等于0的个数，count2是上一个不重复键值的大于等于它且成绩等于1的个数，count_0是上一个不重复键值的成绩为0的个数（可能有多个重复键值），count_1是上一个不重复键值的成绩为1的个数。
利用count1=count1+count_0;count2=count2-count_1;count=count1+count2;计算当前键值的正确数。

要注意count2=count2-count_1;这一句，我起初多加了1，后来调试发现了错误。如果遇到错误要耐心调试，输出一些关键的变量值进行观察思考。

#include <iostream>
#include <vector>
#include <map>
//#include <set>
#include <algorithm>

using namespace std;
bool cmp(pair<int,int> a, pair<int,int> b){
   return a.first<b.first;
}
int main()
{
	int m,y,r;
	int count=0,max=0,count1=0,count2=0,count_0=0,count_1=0;
	cin >> m;
	pair<int,int> p;
	vector<pair<int,int> > v;
	//set<int> s;//存储正确数最大的键值，可以去重并自动排序 
	for(int i=0;i<m;i++)
	{
		cin >> y >> r;
		p.first=y;
		p.second=r;
		v.push_back(p);
	}
	sort(v.begin(),v.end(),cmp);
	int best=v[0].first;
	//处理第一组数值对 
	for(int j=0;j<v.size();j++)
	{
		if(v[j].second==1) count2++;
	}
	int i=0,k=0;
	while(v[i].first==v[i+k].first)
	{
		if(v[i+k].second==1) count_1++;
		else count_0++;
		k++;
	}
	count=count2;
	max=count;
	best=v[0].first;
	//cout << "v[0].first=" << v[0].first << " count="<< count << " count_0="<< count_0<< " count_1="<< count_1<< " count1="<< count1<< " count2="<< count2<<  " max=" << max << " best="<< best<< endl;
	//处理剩余数值对 
	for(int i=1;i<v.size();i++)
	{
		if(v[i].first==v[i-1].first) continue;//重复的不用再检查了 
		else
		{
			count1=count1+count_0;
			count2=count2-count_1;
			count_0=count_1=0;
			int k=0;
			while(v[i].first==v[i+k].first)
			{
				if(v[i+k].second==1) count_1++;
				else count_0++;
				k++;
			}
		}
		count=count1+count2;
		if(count>max||(count==max&&v[i].first>best))
		{
			max=count;
			best=v[i].first;
		} 
		//cout << "v[i].first=" << v[i].first << " count="<< count << " count_0="<< count_0<< " count_1="<< count_1<< " count1="<< count1<< " count2="<< count2<< " max=" << max << " best="<< best<< endl;
	}	
	cout << best << endl; 
	return 0;
}

其中，pair的用法参见博客

看到一位大佬超级简单的算法，利用前缀和思想
前缀和方法100代码
依然是先按照键值排好序。这个算法的优化在于，我的上一个算法只考虑到了局部，所以还要考虑重复键的个数，挺麻烦的；而这个优化算法是从全局来看，先把每一组对应的之前的1的个数记录下来，这样再计算每一组的1,0个数就简单很多。按照y从小到大排序，则当前组上面的result等于0的个数+下面的等于1的个数就是预测正确的个数。

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool cmp(pair<int,int> p1,pair<int,int> p2)
{
	return p1.first<p2.first;
}
int main()
{
	int m,y,result,theta;
	cin >> m;
	pair<int,int> p;
	vector<pair<int,int> > v;
	int count[m];
	for(int i=0;i<m;i++)
	{
		cin >> p.first >> p.second;
		v.push_back(p);
	}
	sort(v.begin(),v.end(),cmp);
	
	count[0]=v[0].second;
	for(int i=1;i<m;i++)//依次记录当前组之前的1总数 
	{
		count[i]=count[i-1]+v[i].second;
	}
	theta=v[0].first;//初始化阈值为第一个键值 
	int maxcount=count[m-1];
	for(int i=1;i<m;i++)
	{
		if(v[i].first==v[i-1].first) continue;//同一个键值只判断一次就好 
		int count_1=count[m-1]-count[i-1];//键值大于等于当前的组中成绩为1的人数 
		int count_0=i-count[i-1];//键值小于当前的组中成绩为0的个数
		int count = count_1+count_0;
		if(count>maxcount||(v[i].first>theta&&count==maxcount))//更新，注意两种情况齐全 
		{
			maxcount=count;
			theta=v[i].first;
		} 
	}
	cout << theta << endl; 
	return 0;
}

测试数据：

6
0 0
1 0
1 1
3 1
5 1
7 1

8
5 1
5 0
5 0
2 1
3 0
4 0
100000000 1
1 0