UVA 1422 Processor（二分极大值极小化+优先队列）

最新推荐文章于 2022-07-14 21:33:16 发布

原创最新推荐文章于 2022-07-14 21:33:16 发布 · 738 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#uva #1422

分治法、二分搜索专栏收录该内容

13 篇文章

订阅专栏

本文介绍了一个给定任务集合的问题，需要在指定的时间范围内完成这些任务。通过使用二分查找法来确定最小完成速率，并利用优先队列进行有效的任务分配。文章提供了一段C++代码实现，展示了如何解决这个问题。

题意：

给定n个任务，每个任务必须在时间[R,D]内完成，每个任务工作量为W，问最小完成速率使得所有工作完成。

思路：

二分求下界的问题，判断的时候利用优先队列，由于时间只有20000，去枚举每个单位时间，看要给分配个那个任务，这步利用优先队列，按d越小越先出队，因为d越小肯定要越快完成越好。

$my$ $code$

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cstdlib>
using namespace std;
typedef long long ll;
const int N = 10005;

int n;
struct Process {
    int r, d, w;
    friend bool operator < (Process a, Process b) {
        return a.d > b.d;
    }
}pro[N];

bool cmp(Process a, Process b) {
    return a.r < b.r;
}

void init() {
    scanf("%d", &n);
    for(int i = 0; i < n; i++) {
        scanf("%d%d%d", &pro[i].r, &pro[i].d, &pro[i].w);
    }
    sort(pro, pro+n, cmp);
}

bool judge(int M) {
    priority_queue<Process> que;
    int idx = 0;
    for(int i = 1; i <= 20000; i++) {
        while(idx < n && pro[idx].r < i)
            que.push(pro[idx++]);
        int speed = M;
        while(speed > 0 && !que.empty()) {
            Process front = que.top();
            que.pop();
            if(front.d < i) return false;
            if(front.w > speed) {
                front.w -= speed;
                speed = 0;
                que.push(front);
            }else {
                speed -= front.w;
            }
        }
        if(que.empty() && idx == n) return true;
    }
    return false;
}

int calc() {
    int L = 1, R = 100000;
    while(L < R) {
        int M = (L+R)/2;
        if(judge(M)) R = M;
        else L = M+1;
    }
    return L;
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        init();
        printf("%d\n", calc());
    }
    return 0;
}