LA 4254 Processor 处理器 【二分 贪心 优先队列】

题目链接：

　　http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=21663

---

二分：

　　最大值最小的问题通过二分来求解。对处理器速度进行二分之后，问题就转化成了对于给定的处理速度，问处理器是否可以将这些问题处理完。

贪心：

　　一个贪心的思路就是每个时刻应该尽量 做可以做的任务中，结束时间最早的那个，这样最起码不会使结果更糟。这样就可以枚举每个单位时间，然后去找可以做的并且结束时间最早的那个去做，直到用完这一单位时间或者无任务可做为止。最后如果发现哪个任务还没做完，就说明在这个给定的处理速度下，处理器是不能完成所有任务的。

优先队列：

　　总体的思路就是，将所有任务按照开始时间排序，二分枚举处理器的速度，然后对每个速度进行判断。按照任务开始时间依次加入优先队列，队列优先级是结束时间早的优先。最后就能判断该速度是否能够执行完所有任务。

---

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<stack>
using namespace std;
#define clr(c) memset(c, 0, sizeof(c));
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef unsigned long long ull;
typedef struct Job{
    int l, r, w;
    bool operator < (const Job& j) const{ // 用于优先队列内部排序
        return r > j.r; // r大的优先级低，优先队列先输出优先级大的成员
    }
    bool operator > (const Job& j) const{
        return j < *this;
    }
}Job;

bool cmp(Job j1, Job j2){ // 用于sort函数
    return j1.l < j2.l; // 当返回true时表示比较结果符合要求，不需要交换位置
}
const int MAXL = 10005;
Job J[MAXL];
int T, n, Begin, End, MaxS, l, r, mid, ans;
bool Ok(int speed){
    priority_queue<Job> Q;
    int pos = 0;
    for(int i = Begin; i <= End; i++){
        int time = speed;
        while(J[pos].l < i && pos < n) Q.push(J[pos++]);
        while(!Q.empty() && time != 0){
            Job Jtemp = Q.top();
            Q.pop();
            if(Jtemp.r < i) return false; // 此时已经过了任务的执行期限， 说明此速度不能完成执行任务
            if(Jtemp.w > time){
                Jtemp.w -= time;
                time = 0;
                Q.push(Jtemp); // 执行一部分任务，此任务未完成部分重新入队
            }
            else time -= Jtemp.w; // 此任务执行完毕， 利用剩余时间执行下一任务
        }
    }
    if(Q.empty()) return true;
    else return false;
}

int main(){
    scanf("%d", &T);
    while(T--){
        Begin = INF, End = 0, MaxS = 0;
        scanf("%d", &n);
        for(int i = 0; i < n; i++){
            scanf("%d%d%d", &J[i].l, &J[i].r, &J[i].w);
            Begin = min(Begin, J[i].l); // 所有任务的最早开始时间
            End = max(End, J[i].r); // 所有任务的最晚结束时间
            MaxS += J[i].w; // 最大速度：在1个单位时间内所有任务都要完成，则速度必须大于等于所有任务的工作量的和
        }
        sort(J, J+n, cmp);
        l = 0, r = MaxS, ans = INF;
        while(l <= r){ // 二分
            mid = (l + r) >> 1; //  (l + r) / 2;
            if(Ok(mid)){
                r = mid -1; // 寻找所有符合要求的速度里面最小的那个
                ans = min(ans, mid);
            }
            else l = mid + 1; // 当前速度不符合要求的话，就必须加大速度
        }
        printf("%d
", ans);
    }

    return 0;
}