uva-1422-Processor

最新推荐文章于 2020-03-02 23:02:09 发布

slowlight93

最新推荐文章于 2020-03-02 23:02:09 发布

阅读量513

点赞数

CC 4.0 BY-SA版权

分类专栏： ACM.贪心

本文链接：https://blog.youkuaiyun.com/slowlight93/article/details/28841543

ACM.贪心专栏收录该内容

6 篇文章

订阅专栏

本文介绍了一个有趣的CPU调度算法实现，通过定义任务结构体并利用优先队列进行任务调度，最终找到能满足所有任务调度条件的时间片长度。代码中详细展示了如何处理任务的到达时间、截止时间和工作量，并通过二分查找确定最优的时间片。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题解参见：http://blog.youkuaiyun.com/fobdddf/article/details/20120845

蛮有趣的有关cpu的算法

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>

using namespace std;

#define F(i, n) for (int i=0;i<(n);++i)
#define LBIT(x) x&-x

long long gcd(long long a, long long b) {
    return b == 0 ? a : gcd(b, a % b);
}

template<class T>
void myswap(T * a, T * b) {
    T tmp = *a;
    *a = *b;
    *b = tmp;
}

#define MAXTASK 10000
#define MAXSIZE 20000
#define MAXLEN 1000

typedef struct tast_type{
    int r;
    int d;
    int i;
    int w;

    bool operator < (const tast_type & b) const {
        return d > b.d;
    }
} task;

task tasks[MAXTASK + 1];
int w[MAXTASK + 1];

int T;
int n;
int l, r, mid;


bool comp(const task & a, const task & b) {
    // 这里用 <= 的话
    // sort 的时候可能出现runtime error
    return a.r < b.r;
}

bool check(int mid) {
    priority_queue<task> pri_que;

    // 当前时间片的起始
    // e.g. 时间片0表示 从0开始的一个时间片，长度为1个单位
    int t = 0;
    int index = 0;
    // 当前时间片可处理的任务量的剩余值
    int rest;

    F(i, n)
        w[tasks[i].i] = tasks[i].w;

    while(true) {
        // 将所有可以使用该时间片的任务进队
        while(index < n && tasks[index].r <= t)
            pri_que.push(tasks[index++]);

        rest = mid;
        while(pri_que.size() && rest > 0) {
              task fr = pri_que.top();
              if (fr.d <= t)
                return false;
              else {
                if (w[fr.i] <= rest) {
                    rest -= w[fr.i];
                    pri_que.pop();
                } else {
                    w[fr.i] -= rest;
                    rest = 0;
                }
              }
        }

        // 所有任务都处理完了
        if (index >= n && (pri_que.size() == 0))
            break;

        ++t;
    }

    return true;
}

int main()
{
    freopen("input.in", "r", stdin);

    cin >> T;

    F(cases, T) {
        cin >> n;
        F(i, n) {
            cin >> tasks[i].r >> tasks[i].d >> tasks[i].w;
            tasks[i].i = i;
        }

        sort(tasks, tasks + n, comp);

        l = 0, r = 5000;

        while(r - l > 1) {
            mid = l + (r - l) / 2;
            if (check(mid))
                r = mid;
            else
                l = mid;
        }

        cout << r << endl;
    }

    return 0;
}