Greedy:Cleaning Shifts(POJ 2376)

　　　　　　　　　　

　　　　　　　　　　　　   牛的大扫除

　　题目大意：农夫有N只牛，这些牛要帮助打扫农舍，这些牛只能打扫固定位置（千万要注意这个位置不是连续的），每一段区间必须至少有一只牛打扫，问你至少需要多少只牛？（如果区间不能完全被覆盖，则输出-1）。

　　这一题有点像上次的萨鲁曼军队，就是一个区间贪婪算法，我们尽可能的由一个方向往前找到最大的区间就可以了（如果与本位置的endT的间隔相同，找最远的，贪婪的最基本的思想）。

　　这一题本身不难，但是特判很恶心，一不小心就要出错了，比如1 5 3 1这样的输入，就直接输出-1就可以了（一定要有牛打扫1），还有，更关键的是，区间是不连续的（也就是扫完了13，下一次还可以扫46），一定要注意这一点！

　　

#include <iostream>
#include <functional>
#include <algorithm>

using namespace std;
typedef struct cows_t
{
    int start_T;
    int end_T;
}Cow_Set;

Cow_Set cows[25000];
void Search(const int, const int);
int fcmop(const void *a, const void *b)
{
    return (*(Cow_Set *)a).start_T - (*(Cow_Set *)b).start_T;
}

int main(void)
{
    int N, T;
    while (~scanf("%d%d", &N, &T))
    {
        for (int i = 0; i < N; i++)
            scanf("%d%d", &cows[i].start_T, &cows[i].end_T);
        qsort(cows, N, sizeof(Cow_Set), fcmop);
        Search(N, T);
    }

    return 0;
}

void Search(const int N, const int T)
{
    int et = 1, pos = 0, tmp_pos = -1, ans = 0, tmp_maxt, j;
    if (cows[0].start_T != 1)
    {
        cout << -1 << endl;
        return;
    }
    while (1)
    {
        if (cows[pos].start_T > et + 1)//说明没有牛可以突破当前这个上一个时间界限，不用找了
        {
            cout << -1 << endl;
            return;
        }
        ans++;//增加一头开始的那头牛
        if (cows[pos].end_T >= T)
            break;
        tmp_maxt = 0; tmp_pos = pos;
        for (j = pos + 1; j < N && (cows[j].start_T <= cows[pos].end_T + 1); j++)//找到间隔比当前T还要长的牛(记得T可以间隔1)
        {
            if (cows[j].end_T - cows[pos].end_T >= tmp_maxt)//要带等号，尽量往前
            {
                tmp_pos = j;
                tmp_maxt = cows[j].end_T - cows[pos].end_T;
            }
        }
        if (tmp_pos == pos)
        {
            cout << -1 << endl;
            return;
        }
        pos = tmp_pos;
        et = cows[tmp_pos].start_T;
    }
    if (ans != 0)
        printf("%d
", ans);
    else
        cout << -1 << endl;
}