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[];
 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 = ; 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 ;
 }

 void Search(const int N, const int T)
 {
     int et = , pos = , tmp_pos = -, ans = , tmp_maxt, j;
     if (cows[].start_T != )
     {
         cout << - << endl;
         return;
     }
     while ()
     {
         if (cows[pos].start_T > et + )//说明没有牛可以突破当前这个上一个时间界限，不用找了
         {
             cout << - << endl;
             return;
         }
         ans++;//增加一头开始的那头牛
         if (cows[pos].end_T >= T)
             break;
         tmp_maxt = ; tmp_pos = pos;
         for (j = pos + ; j < N && (cows[j].start_T <= cows[pos].end_T + ); 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 << - << endl;
             return;
         }
         pos = tmp_pos;
         et = cows[tmp_pos].start_T;
     }
     if (ans != )
         printf("%d\n", ans);
     else
         cout << - << endl;
 }