ZOJ1012-Mainframe 贪心策略

最新推荐文章于 2021-10-08 09:32:50 发布

原创最新推荐文章于 2021-10-08 09:32:50 发布 · 535 阅读

0 ·

CC 4.0 BY-SA版权

浙大ACM 专栏收录该内容

18 篇文章

订阅专栏

本文介绍了一种基于任务到达时间和报酬优先级的任务调度算法。通过使用邻接矩阵存储边和权，并定义结构体来表示任务属性，如CPU使用量、内存使用量、到达时间等。该算法首先读取输入文件中的任务数据，然后对任务进行排序，优先考虑到达时间早且报酬高的任务。最终目标是在给定的资源限制下最大化总收益。

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

将任务按到达时间和报酬大小的优先级排列

#include<iostream>
#include<vector>
#include<string>
#include<set>
#include<memory.h>
#include<cstdio>
#include<list>
#include<string>
#include<map>
#include<cmath>
#include <algorithm>
#include <queue>

#define NUM 1000
#define maxint 10000000
#define INF 0x3f3f3f3f
#define Max 10001
using namespace std;

int c[NUM][NUM];//用邻接矩阵存储边和权
int dist[NUM];
string a;
int k;



struct Node
{
    int a ;//使用的CPU的个数
    int b ;//使用的内存
    int t ;//到达时间
    int u ;//时限
    int v ;//报酬
    int w ;//奖励
    int x ;//罚款
};
int cmp(const void * A, const void * B)
{
    struct Node * C = (Node *)A;
    struct Node * D = (Node *)B;
    if(C->t != D->t) return C->t-D->t;
    else
    {
        return D->v-C->v;
    }
}
int main()
{
    freopen("in.txt", "r", stdin);
    int f;
    int m, n, l;
    Node Job[Max];
    bool Finished[Max];
    int Case = 0;
    while(cin>>f && f)
    {
        Case++;
        int profit = 0;
        memset(Finished, 0, sizeof(Finished));
        int m,n,l;
        cin>>m>>n>>l;
        for(int i = 0;i<l;i++)
        {
            cin>>Job[i].a>>Job[i].b>>Job[i].t>>Job[i].u>>Job[i].v>>Job[i].w>>Job[i].x;
        }
        qsort(Job,l,sizeof(Node),cmp);
        for(int i = 0;i<f;i++)
        {
            int cpu = m;
            int memory = n;
            for(int j = 0;j<l;j++)
            {
                if(Job[j].t>i) break;
                if((Job[j].a <= cpu )&& (Job[j].b <= memory) && (!Finished[j]))
                {
                    cpu -=Job[j].a ;
                    memory-=Job[j].b;
                    Finished[j] = true;
                    profit += Job[j].v + ((Job[j].u-(i+1))>=0 ? Job[j].w : Job[j].x)*(Job[j].u-(i+1));
                }
            }
        }
        for(int i = 0;i<l;i++)
        {
            if(!Finished[i] && Job[i].u<=f)
            {
                profit -= Job[i].x*(f-Job[i].u);
            }
        }
        cout<<"Case "<<Case<<": "<<profit<<endl<<endl;
    }
    
    
}