我们曾经或即将经历的招聘会

题目背景： 那一年，这一年，青春散场，到毕业季，我们奔波着忙着找工作，来到招聘会上，看到黑压压的一大片人群.. 题目描述：毕业季，很多大公司来学校招聘，招聘会分散在不同时间段，小明想知道自己最多能完整的参加多少个招聘会(参加一个招聘会的时候不能中断或离开)。 假设现在有n个招聘会，每个招聘会都有个起止时间，时间由从招聘会第一天0点开始的小时数表示，n <=
1000 。 返回：最多参加的招聘会的个数n。 举个例子： 现在有3场招聘会，他们的起始时间为： 9-10 10-20 8-15

#include "stdafx.h"
#include <string>
#include <cmath>
#include <cstdio>
#include <set>
#include <map>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int possible_count(int start, map<int, int>& data, bool main);

int forjob(vector<pair<int,int> > &time)
{
// 首先排序分组分成24组
map<int, vector<pair<int,int>>> data_group_unsort;
for_each(time.begin(), time.end(),[&data_group_unsort](pair<int, int> data)->void
{
data_group_unsort[data.first].push_back(data);
});

// 然后对每组内的数据排序，去除一样的
map<int, set<int>> data_group_sorted;
for_each(data_group_unsort.begin(), data_group_unsort.end()
,[&data_group_sorted](pair<int, vector<pair<int,int>>> data)->void
{
for_each(data.second.begin(), data.second.end()
,[&data_group_sorted, &data](pair<int, int> data_p)->void
{
data_group_sorted[data.first].insert(data_p.second);
});
});

map<int, vector<pair<int,int>>>::iterator iter = data_group_unsort.begin();
for (;iter!=data_group_unsort.end();++iter)
{
vector<pair<int,int>>::iterator iter2 = iter->second.begin();
for (;iter2!=iter->second.end();++iter2)
{
data_group_sorted[iter->first].insert(iter2->second);
}
}

// 保留最终有效的数据
map<int, int> data_final;
for_each(data_group_sorted.begin(), data_group_sorted.end()
,[&data_final](pair<int, set<int>> data)->void
{
data_final[data.first] = *(data.second.begin());
});

// 至此，简化成最多24个数据的复杂度
return  possible_count(0, data_final, true);

}

// 参加start点的，还能参加机场
int possible_count(int start, map<int, int>& data, bool main)
{
static map<int, int> temp_data;

if (start >= (--data.end())->first)
{
temp_data[start] = (main?0:1);
return temp_data[start];
}

if (temp_data.find(start) != temp_data.end())
return temp_data[start];

if (data.find(start) == data.end())
{
temp_data[start] =  possible_count(start + 1, data, false);
}
else
{
temp_data[start] = max(possible_count(start + 1, data, true), 1 + possible_count(data.find(start)->second, data, false));
}

return temp_data[start];
}

int main()
{
vector<pair<int, int>> data;
int all = 1000;
for (int i=0;i<all;++i)
{
int start = rand()%25;
int end = start;
while (start == end)
{
end = rand()%25;
}

data.push_back(pair<int, int>(start<end?start:end, end>start?end:start));
}

int x = forjob(data);

cout<<x;
return x;

}