PAT乙级1015.德才论（25）——（C++）标准库排序总结（sort）

1. 题目

宋代史学家司马光在《资治通鉴》中有一段著名的“德才论”：“是故才德全尽谓之圣人，才德兼亡谓之愚人，德胜才谓之君子，才胜德谓之小人。凡取人之术，苟不得圣人，君子而与之，与其得小人，不若得愚人。”

现给出一批考生的德才分数，请根据司马光的理论给出录取排名。

1.1 输入格式：

输入第1行给出3个正整数，分别为：N（<=105），即考生总数；L（>=60），为录取最低分数线，即德分和才分均不低于L的考生才有资格被考虑录取；H（<100），为优先录取线——德分和才分均不低于此线的被定义为“才德全尽”，此类考生按德才总分从高到低排序；才分不到但德分到线的一类考生属于“德胜才”，也按总分排序，但排在第一类考生之后；德才分均低于H，但是德分不低于才分的考生属于“才德兼亡”但尚有“德胜才”者，按总分排序，但排在第二类考生之后；其他达到最低线L的考生也按总分排序，但排在第三类考生之后。

随后N行，每行给出一位考生的信息，包括：准考证号、德分、才分，其中准考证号为8位整数，德才分为区间[0, 100]内的整数。数字间以空格分隔。

1.2 输出格式：

输出第1行首先给出达到最低分数线的考生人数M，随后M行，每行按照输入格式输出一位考生的信息，考生按输入中说明的规则从高到低排序。当某类考生中有多人总分相同时，按其德分降序排列；若德分也并列，则按准考证号的升序输出。

1.3 样例：

1. 输入样例
   14 60 80
   10000001 64 90
   10000002 90 60
   10000011 85 80
   10000003 85 80
   10000004 80 85
   10000005 82 77
   10000006 83 76
   10000007 90 78
   10000008 75 79
   10000009 59 90
   10000010 88 45
   10000012 80 100
   10000013 90 99
   10000014 66 60
2. 输出样例：
   12
   10000013 90 99
   10000012 80 100
   10000003 85 80
   10000011 85 80
   10000004 80 85
   10000007 90 78
   10000006 83 76
   10000005 82 77
   10000002 90 60
   10000014 66 60
   10000008 75 79
   10000001 64 90
   pat题目内容

2. 排序分析

2.1排序函数

此题需要用到标准库排序函数，正好借此总结一下标准库的排序函数。

1. sort， 对给定区间所有元素进行排序
2. stable_sort，对给定区间所有元素稳定排序
3. partial_sort，对给定区间所有元素部分排序

2.2排序函数的区别

三个函数都在<algojrithm>库中

1. sort接受两个迭代器用来表示范围，对范围内的数进行排序。例如：sort(V.begin(),V.end());即对整个V容器进行升序排列。
2. stable_sort 的稳定排序表示维持相等元素的原有顺序，但此时必须定义==运算符。
3. partial_sort必须接受三个值，beg,mid,end.对mid-beg个元素进行排序，也就是说，如果mid-beg等于42，则该函数将有序次序中的最小值元素放在序列中的前42个位置。部分排序完成之后，从beg到mid(但不包括mid)范围内的元素是有序的，已排序范围内没有元素大于mid之后的元素。未排序元素之间的次序是未指定的。

2.3降序方法

默认情况下是按升序排序，即从小到大排列，那如何实现降序呢，下面介绍几种方法：

1. 使用接受谓词的重载sort版本
   谓词是一个可调用的表达式，其返回结果是一个能用作条件的值。有一元谓词和二元谓词两种。分别为接受单一参数和接受两个参数。例如：

//比较函数，用来按长度排序单词
bool isShorter (const string &s1, const string &s2)
{
     return s1.size() < s2.size();
}
bool islonger (const string &s1, const string &s2)
{
     return s1.size() > s2.size();
}
//按长度由短至长排序words
sort(words.begin(), words.end(), isShorter);
//按长度由长至短排序words
sort(words.begin(), words.end(), islonger);

其实完全可以把谓词看成一种返回bool的函数，只是最多只能接受两个参数。
对于说可以重载<运算符的方法，我表示完全不赞同，因为那样的程序很难读懂，不是简单明了的。

2. 使用标准库bind函数
   可以将bind函数看做一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。它定义在头文件functional中。
   调用bind的一般形式为：auto newCallable = bind(callable, arg_list);
   其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，当我们调用newCallable时，newCallable会调用callable，并传递给它 arg _list中的参数。
   例如：

//g是一个有两个参数的可调用对象
auto g = bind(f, a, b, _2, c _1);
//下面两个调用是相同的结果
g(X,Y);
f(a, b, Y, c, X);

这时，我们可以用bind来颠倒isShorter的含义了：

//按长度由短至长排序words
sort(words.begin(), words.end(), isShorter);
//按长度由长至短排序words
sort(words.begin(), words.end(), bind(isShorter, _2, _1));

在第二个调用中，传递给isShorter的参数被交换过来了，就好像调用isShorter(B,A)一样。

3. 对输出做手脚。直接按升序排序，但输出时用反向迭代器倒序输出就可以了，哈哈，这其实就不算降序排序。本题德才论我就是用的这个方法，注意输出用cout会超时.直接按升序排序，但输出时用反向迭代器倒序输出就可以了，哈哈，这其实就不算降序排序。本题德才论我就是用的这个方法，注意输出用cout会超时.

3. 答案代码如下：

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

struct student {
	int number;
	int scored;//德分
	int scorec;//才分
	int totalscore;
	friend istream &operator>> (istream &is, student &c);
	
};
istream &operator>> (istream &is, student &c)
{
	is >> c.number >> c.scored >> c.scorec;
	if (is)
	{
		c.totalscore = c.scored + c.scorec;
	}
	else c = student();
	return is;
}
bool operator<(const student &lhs, const student &rhs)
{
	if (lhs.totalscore == rhs.totalscore)
	{
		if (lhs.scored == rhs.scored)
		{
			return lhs.number < rhs.number;
		}
		else return lhs.scored < rhs.scored;
	}
	else return lhs.totalscore < rhs.totalscore;
}
int main()
{
	vector<student> A, B, C, D;//存放四类学生
	int N, L, H;
	cin >> N >> L >> H;
	student s;
	for (int i = 0; i < N; i++)
	{
		if (cin >> s)
		{
			if ((s.scored >= H) && (s.scorec >= H)) A.push_back(s);
			else if ((s.scored >= H) && (s.scorec >= L) && (s.scorec < H)) B.push_back(s);
			else if ((s.scored >= L) && (s.scored < H) && (s.scorec >= L) && (s.scorec < H) && (s.scored >= s.scorec)) C.push_back(s);
			else if ((s.scored >= L) && (s.scored < H) && (s.scorec >= L)) D.push_back(s);
		}
	}
	sort(A.begin(), A.end());
	sort(B.begin(), B.end());
	sort(C.begin(), C.end());
	sort(D.begin(), D.end());
	cout << A.size() + B.size() + C.size() + D.size() << endl;
	for (auto it = A.rbegin(); it != A.rend();it++)
	{
		printf("%d %d %d\n", it->number, it->scored, it->scorec);
	}
	for (auto it = B.rbegin(); it != B.rend(); it++)
	{
		printf("%d %d %d\n", it->number, it->scored, it->scorec);
	}
	for (auto it = C.rbegin(); it != C.rend(); it++)
	{
		printf("%d %d %d\n", it->number, it->scored, it->scorec);
	}
	for (auto it = D.rbegin(); it != D.rend(); it++)
	{
		printf("%d %d %d\n", it->number, it->scored, it->scorec);
	}
    return 0;
}