会场安排问题

题目链接：http://acm.nyist.net/JudgeOnline/problem.php?pid=14

经典问题。此题的最佳解法是用贪心算法：

1) 将所有输入活动按照结束时间从早到晚排序
2) 顺序遍历列表，将可以加入日程的活动加入，并维护活动计数
3) 遍历完毕后，输出活动计数
整个过程需要1) 将活动列表排序O(nlogn) 2) 遍历列表O(n)，因此复杂度为O(nlogn)

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

bool Comp(const pair<int ,int > A1, const pair< int ,int > A2)
{
    return A1.second < A2.second;
}

void greedySelect()
{

    int start,finish;
    int m;
    cin >> m;
    while(m--){
        int n;
        cin >> n;
        vector< pair<int,int> > Avec;
        vector< pair<int ,int> > Svec;
        while(n-- )
        {
            cin >> start >> finish;
            Avec.push_back(make_pair(start,finish));
        }
        cin.clear();
        sort(Avec.begin(),Avec.end(),Comp);
        vector< pair<int,int> >::iterator iter = Avec.begin();
        Svec.push_back(make_pair(iter->first,iter->second));
        finish = iter->second;
        for( ++iter;iter != Avec.end();++iter)
            if(iter->first > finish) 
            {
                Svec.push_back(make_pair(iter->first,iter->second));
                finish = iter->second;
            }
            cout << Svec.size() << endl; 
    }
}
int main()
{
    greedySelect();
    return 0;
}

以下是我ac的解法，没有标准解法优，在此只是存下来留个念想，其他人可以直接忽略。

---

我的思路是：

1. 递归穷举（这个解法TLE，没什么价值，忽略）

2. 贪心（基于起始时间排序）

1) 对活动按照开始时间排序
2) 消去不可能活动（肯定安排不到的活动）

不可能活动的定义：在所有n个活动ai(i=1, 2 ... n)组成的集合S中，对于任意的ai∈S，若存在aj∈S(i≠j)，使得b(aj)≤b(ai), e(aj)≥e(ai)（b,e代表开始时间/结束时间），则aj一定不在使得活动数最多的活动集合中，可以将其从S中删去。活动aj即为不可能活动。
举个例子，以下几个活动集（一行为一个集合）中，只有红字的活动需要考虑，其它都可以删除。
{3,4} {2,4} {1,4} {1,5}
{2,3} {1,3} {2,4} {2,3}

删除不可能活动最简单的方法就是二层嵌套循环，复杂度为O(n^2)，为了降低复杂度，可以在第1) 步的排序上做一些工作。
例如可以对活动按照(b↑e↓) 进行排序，这样可以使得在初始的几重循环中删去尽量多的元素，从而降低一些时间复杂度。

3) 按照贪心方法安排活动

遍历列表，将所有能够加入的活动加入。遍历完毕后，输出活动计数。

算法需要一次排序(O(nlogn))，一次嵌套循环(O(n^2))，因此复杂度为O(n^2)

标准解法和我的贪心解法都可以得到ac，不过标准解法在时间上明显优于我的解法。

标准解法：时间260内存308
我的解法：时间800内存308

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

typedef struct _AR{
    int b;
    int e;
}AR;

bool operator<(const AR &a, const AR &b){
    if (a.b == b.b) return a.e > b.e;
    return a.b < b.b;
}

vector<AR> arv;

template < class T >
void reverse(vector<T> &v){
    T temp;
    for (int i = 0; i < v.size()/2; i ++){
        temp = v[i];
        v[i] = v[v.size()-i-1];
        v[v.size()-i-1] = temp;
    }
}

void reduce(vector<AR> &v){

    reverse(v);

    vector<AR>::iterator it = v.begin();
    vector<AR>::iterator it2;
    while (it != v.end()){
        it2 = it;
        it2++;
        while (it2 != v.end()){
            if (it2->e >= it->e){
                v.erase(it2);
            }
            else{
                it2 ++;
            }
        }
        it ++;
    }

    reverse(v);

}

int main()
{

    int n;
    cin>>n;
    while (n--){
        arv.clear();
        int c;
        cin>>c;
        while (c--){
            int b, e;
            cin>>b>>e;
            AR a;
            a.b = b;
            a.e = e;
            arv.push_back(a);
        }
        sort(arv.begin(), arv.end());
        reduce(arv);

        int r = -1;
        int count = 0;
        for (vector<AR>::iterator it = arv.begin(); it != arv.end(); it ++){
            if (it->b > r){
                r = it->e;
                count ++;
            }
        }
        
        cout<<count<<endl;
    }

    return 0;
}