处理器（Processor，Seoul 2008，LA 4254）

AC通道：
https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2255

处理器

Description

有 n 个任务，每个任务有 3 个参数 ri、di 和 wi ，表示必须在时刻 [ri,di] 之内执行，工作量为 wi 。
处理器执行的速度可以变化，当执行速度为 s 时，一个工作量为 wi 的任务需要执行 wi/s 个单位时间。
另外，任务不一定要连续执行，可以分成若干块。
你的任务时求出处理器在执行过程中最大速度的最小值。
处理器速度可以是任意整数值。

假设有 5 个任务， ri 和 di 分别是 [1,4] ， [3,6] ， [4,5] ， [4,7] ， [5,8] ，工作量分别为 2,3,2,2,1 ，则下图是一个最优执行方案，最大速度为 2 。

Input

输入的第一行为数据组数 T （ T≤20 ）。
每组数据的第一行为整数 n （ 1≤n≤10000 ）；
以下 n 行每行包含 3 个整数 ri,di,wi （ 1≤ri<di≤2000 ， 1≤wi≤1000 ）。

Output

对于每组数据，输出在执行过程中处理器最大速度的最小值。

Sample Input

3
5
1 4 2
3 6 3
4 5 2
4 7 2
5 8 1
6
1 7 25
4 8 10
7 10 5
8 11 5
10 13 10
11 13 5
8
15 18 10
20 24 16
8 15 33
11 14 14
1 6 16
16 19 12
3 5 12
22 25 10

Sample Output

2
5
7

Solution

首先，这个题目有点坑的是，当你判断时间为 x ，第 i 个任务能不能执行时，需要满足的条件是： ri≤x && di>x ，因为这个任务并不是在这个时间点执行，而是在这个时间点与下一个时间点之间执行。

二分答案。

首先按 ri 排序。

枚举每个时间点，对于这个时间点上的任务，我们按照 di 从小到大进行执行。
这就需要用到优先队列。

还有一个优化：当优先队列为空时，可以直接跳到下一个任务的开始时间。

Code

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>

using namespace std;

const int MAXN=10000;

struct Pro{
    int l,r,w;
    bool operator > (const Pro&b)const{
        return r>b.r;
    }
}s[MAXN+10];

priority_queue<int,vector<Pro>,greater<Pro> > q;

inline int Max(int x,int y){
    return x>y?x:y;
}

bool cmp(Pro x,Pro y){
    return (x.l<y.l);
}

inline int in(){
    int ans=0;
    char x=getchar();
    while(x<‘0’||x>‘9’)x=getchar();
    while(x>=‘0’&&x<=‘9’){ans=ans*10+x-‘0’;x=getchar();}
    return ans;
}

int T,n;
int maxn;

bool pan(int speed){
    while(!q.empty())q.pop();
    int now=1;
    for(int i=1;i<=maxn;i++){
        if(q.empty()){
            if(now>n)return true;
            i=s[now].l;
        }
        while(now<=n&&s[now].l<=i)q.push(s[now++]);
        int tmp=speed;
        while(tmp>0&&!q.empty()){
            Pro t=q.top();
            q.pop();
            if(t.r<=i)return false;
            if(t.w>tmp){
                t.w-=tmp;
                tmp=0;
                q.push(t);
            }
            else
                tmp-=t.w;
        }
    }
    return false;
}

int main(){
    T=in();
    while(T–){
        maxn=0;
        n=in();
        for(int i=1;i<=n;i++){
            s[i].l=in();s[i].r=in();s[i].w=in();
            maxn=Max(maxn,s[i].r);
        }
        sort(s+1,s+n+1,cmp);
        int l=1,r=maxn,ans=maxn;
        while(l<=r){
            int mid=(l+r)/2;
            bool flag=pan(mid);
            if(flag){
                if(ans>mid)ans=mid;
                if(r!=mid-1)r=mid-1;
                else break;
            }
            else{
                if(l!=mid+1)l=mid+1;
                else break;
            }
        }
        printf(”%d\n”,ans);
    }
    return 0;
}