一千题，No.0007（看电视）

描述

暑假到了，小明终于可以开心的看电视了。但是小明喜欢的节目太多了，他希望尽量多的看到完整的节目。

现在他把他喜欢的电视节目的转播时间表给你，你能帮他合理安排吗？

输入描述

输入包含多组测试数据。每组输入的第一行是一个整数n（n<=100），表示小明喜欢的节目的总数。

接下来n行，每行输入两个整数si和ei（1<=i<=n），表示第i个节目的开始和结束时间，为了简化问题，每个时间都用一个正整数表示。

当n=0时，输入结束。

输出描述

对于每组输入，输出能完整看到的电视节目的个数。

用例输入 1 

12
1 3
3 4
0 7
3 8
15 19
15 20
10 15
8 18
6 12
5 10
4 14
2 9
0

用例输出 1 

5

解题思路：

用贪心遍历每次加上最接近并且时间最短的即可，特别注意的是，很多人在贪心排列的时候以开始时间或者耗时来排序，这样可能造成一些bug，应该用结束时间排列，因为只有结束时间才会影响是否能参加其他事件，并且因为开始时间会小于结束时间不会导致出现其他的结果。

c++代码如下

#include <bits/stdc++.h>

using namespace std;


int main()
{
    int n;
    cin >> n;
    multimap<int,pair<int,int>> m;
    while(n--)
    {
        int x,y;
        cin >> x >> y;
        m.insert({y,{x,y}});
    }

    int t;
    int res = 1;
    t = m.begin()->first;
    for(auto &elem : m)
    {
        if(elem.second.first >= t)
        {
            ++res;
            t = elem.first;
        }
    }
    cout << res;
}

当然也可以用其他的方法

下文用BFS的方法

c++代码如下：

#include <bits/stdc++.h>

#define elemtype char
using namespace std;

struct tim
{
    tim(int x,int y,int z)
    :_begin(x)
    ,_end(y)
    ,_step(z)
    {

    }
    int _begin;
    int _end;
    int _step;
};

deque<tim> a;//用于遍历
int max = 1;//记录最大step

void BFS(deque<tim> &d)
{
    while(!d.empty())
    {
        bool b = true;
        for(auto &elem : a)
        {
            if(d.begin()->_end <= elem._begin)
            {
                b = false;
                d.push_back(tim(elem._begin,elem._end,d.begin()->_step+1));
            }
        }
        if(b)
        {
            if(::max < d.begin()->_step)
            {
                ::max = d.begin()->_step;
            }
        }
        d.erase(d.begin());
    }
}

int main()
{
    deque<tim> d;
    int n;
    cin >> n;
    if(n == 0)
    {
        cout << 0;
    }
    else
    {
        while(n--)
        {
            int x,y;
            cin >> x >> y;
            tim t(x,y,1);
            d.push_back(t);//每个时间都能当作开头，所以全部入队
            a.push_back(t);
        }
        cin >> n;//把最后的0输进去

        BFS(d);
        cout << ::max;
    }
}