算法（九）贪心算法之排队问题

题目描述：

Suppose you have a random list of people standing in a queue. Each person is described by a pair of integers (h, k), where h is the height of the person and k is the number of people in front of this person who have a height greater than or equal to h. Write an algorithm to reconstruct the queue.

Note:

The number of people is less than 1,100.

Example

Input:

[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]

Output:

[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]

解题思路：

从身高最矮的人开始。对传进来的数据进行排序，矮的在前，身高一样的话就比他高的人多的排在前面，然后对这个数据容器（vector）进行遍历。开辟一个空间重新存储这个队列。每次遍历容器的一个元素，则这个元素在新队列的位置由这个元素的第二个参数（比他高的人的数目）决定，这个数字是多少则在他前面应当刚好有这个数字的空位。如此遍历下来刚好能填满新空间。代码如下：

struct person {
int height;
int heighterPeople;
int flag;
person() {
flag = 0;//这个位置是否为空
height = 0;
heighterPeople = 0;
}
};
class Solution {
public:
static bool sort_people(pair<int, int> & a, pair<int, int>& b) {
if (a.first < b.first)
return true;
else if (a.first == b.first && a.second > b.second)
return true;
return false;
}
vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people) {
if (people.size() == 0)
return people;
sort(people.begin(), people.end(), sort_people);
person * p = new person[people.size()];
vector<pair<int, int>>::iterator iter = people.begin();
for (; iter != people.end(); ++iter) {
int count = 0, insertPosition = 0;
for (int insertPosition = 0; insertPosition < people.size(); ++insertPosition) {
if (p[insertPosition].flag == 0 && iter->second == count) {
p[insertPosition].flag = 1;
p[insertPosition].height = iter->first;
p[insertPosition].heighterPeople = iter->second;
break;
}
if (p[insertPosition].flag == 0) {
count++;
}
}
}
vector<pair<int, int>> temp;
pair <int, int> store;
for (int i = 0; i < people.size(); ++i) {
store.second = p[i].heighterPeople;

b7ed
store.first = p[i].height;
temp.push_back(store);
}
return temp;
}
};

从身高最高的人开始。按身高对数据进行排序，身高一样则比其身高高的人数小的排在前面。遍历这个数据容器（vector），每次都将遍历的元素放到新容器中，位置则是容器的开始位置加上元素的第二个参数（比其身高高的人数）代码如下：

vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people) {
auto comp = [](const pair<int, int>& p1, const pair<int, int>& p2)
{ return p1.first > p2.first || (p1.first == p2.first && p1.second < p2.second); };
sort(people.begin(), people.end(), comp);
vector<pair<int, int>> res;
for (auto& p : people)
res.insert(res.begin() + p.second, p);
return res;
}

注意一下第一种方法中的排序函数的实现：

需要声明为静态的

要确保无论哪一种情况都有return值，所以这个函数最后一行代码不能删除。