CCF-CSP 202203-3 计算资源调度器 100分

已于 2022-06-12 12:21:19 修改
阅读量1k 收藏 4
点赞数 2
分类专栏： CCF-CSP 文章标签： c++
于 2022-06-05 21:46:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45791939/article/details/125137344
版权

原题链接：CCF-CSP 202203-3 计算资源调度器
在这里插入图片描述
代码贴出来自己都不好意思，全TM复制粘贴

代码的结构大致是这样：

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N=1010;

struct Node
{
    int id;//编号
    int tasksum;//任务数
    int area;//可用区
    map<int,int> mp;//任务-应用
    friend bool operator < (const Node& a,const Node& b )
    {
        if(a.tasksum!=b.tasksum) return a.tasksum>b.tasksum;
        else return a.id>b.id;
    }
};

vector<int> Area[N];//每个可用区上的节点编号
int num=0;//任务数
priority_queue<Node> pq;
map<int,set<int>> apply;//每个应用对应的可用区

int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    int n,m;
    cin>>n>>m;
    //输入计算节点
    for(int i=1;i<=n;i++)
    {
        int li; cin>>li;
        Node x;
        x.area=li;
        x.id=i;
        x.tasksum=0;
        pq.push(x);
        Area[li].push_back(i);
    }
    int g; cin>>g;
    while(g--)
    {
        int f,a,na,pa,paa,paar;
        cin>>f>>a>>na>>pa>>paa>>paar;
        int pre=num;
        if(paa==0)//没有计算任务反亲和性要求
        {
            if(na)//计算任务必须在指定可用区na上运行
            {
                 if(Area[na].size()==0) //编号为na的可用区上没有结点
                 {
                     for(int j=0;j<f;j++) cout<<0<<" ";
                     cout<<endl;
                     continue;
                 }
                 else if(Area[na].size()>0 && pa==0)
                 {
                     priority_queue<Node> tmp;
                     int cnt=0;
                     while(cnt<f)
                     {
                        Node x=pq.top();
                        pq.pop();
                        if(x.area==na)
                        {
                             x.tasksum++;
                             num++;
                             x.mp[num]=a;
                             apply[a].insert(x.area);
                             cout<<x.id<<" ";
                             cnt++;
                             pq.push(x);
                        }
                        else tmp.push(x);
                     }
                     while(!tmp.empty())
                     {
                          Node y=tmp.top();
                          pq.push(y);
                          tmp.pop();
                     }
                 }
                 else if(Area[na].size()>0 && pa>0)//必须和必须和编号为pa的应用的计算任务在同一个可用区运行；
                 {
                     priority_queue<Node> tmp;
                     int cnt=0;
                     if(apply[pa].size()==0)
                     {
                        while(cnt<f)
                        {
                            cout<<0<<" ";
                            cnt++;
                        }
                        cout<<endl;
                        continue;
                     }
                     while(!pq.empty() && cnt<f)
                     {
                        Node x=pq.top();
                        pq.pop();
                        if(apply[pa].count(x.area))
                        {
                            if(x.area==na)
                            {
                                cout<<x.id<<" ";
                                apply[a].insert(x.area);
                                x.tasksum++;
                                num++;
                                x.mp[num]=a;
                                cnt++;
                                pq.push(x);
                            }
                            else tmp.push(x);
                        }
                        else tmp.push(x);
                    }
                    while(cnt<f)
                    {
                        cout<<0<<" ";
                        cnt++;
                    }
                    while(!tmp.empty())
                    {
                        Node y=tmp.top();
                        pq.push(y);
                        tmp.pop();
                    }
                 }
            }
            else if(na==0 &&pa==0)//没有计算节点亲和性要求
            {
                priority_queue<Node> tmp;
                int cnt=0;
                while(cnt<f)
                {
                    Node x=pq.top();
                    x.tasksum++;
                    num++;
                    x.mp[num]=a;
                    apply[a].insert(x.area);
                    cout<<x.id<<" ";
                    cnt++;
                    pq.pop();
                    pq.push(x);
               }
            }
            else if(na==0 &&pa>0)//必须和必须和编号为pa的应用的计算任务在同一个可用区运行；
            {
                priority_queue<Node> tmp;
                int cnt=0;
                if(apply[pa].size()==0)
                {
                    while(cnt<f)
                    {
                        cout<<0<<" ";
                        cnt++;
                    }
                    cout<<endl;
                    continue;
                }
                while(!pq.empty() && cnt<f)
                {
                    Node x=pq.top();
                    pq.pop();
                    if(apply[pa].count(x.area))
                    {
                        cout<<x.id<<" ";
                        apply[a].insert(x.area);
                        x.tasksum++;
                        num++;
                        x.mp[num]=a;
                        cnt++;
                        pq.push(x);
                    }
                    else tmp.push(x);
                }
                while(cnt<f)
                {
                    cout<<0<<" ";
                    cnt++;
                }
                while(!tmp.empty())
                {
                    Node y=tmp.top();
                    pq.push(y);
                    tmp.pop();
                }
            }
        }
        else //不能和编号为paa的应用的计算任务在同一个计算节点上运行
        {
            if(na)
            {
                if(Area[na].size()==0) //编号为na的可用区上没有节点
                {
                    for(int j=0;j<f;j++) cout<<0<<" ";
                    cout<<endl;
                    continue;
                }
                else if(Area[na].size()>0 && paar==1 && pa==0)//必须满足
                {
                    priority_queue<Node> tmp;
                    int cnt=0;
                    while(!pq.empty() && cnt<f)
                    {
                        int flag=0;
                        Node x=pq.top();
                        pq.pop();
                        if(x.area==na)
                        {
                            for(auto tt:x.mp)
                            {
                                if(tt.second==paa)
                                {
                                    flag=1; break;//如果该节点有编号为paa的应用的计算任务
                                }
                            }
                            if(flag==0)
                            {
                                cout<<x.id<<" ";
                                apply[a].insert(x.area);
                                x.tasksum++;
                                num++;
                                x.mp[num]=a;
                                cnt++;
                                pq.push(x);
                            }
                            else tmp.push(x);
                        }
                        else tmp.push(x);
                    }
                    while(cnt<f)
                    {
                        cout<<0<<" ";
                        cnt++;
                    }
                    while(!tmp.empty())
                    {
                        Node y=tmp.top();
                        pq.push(y);
                        tmp.pop();
                    }
                }
                else if(Area[na].size()>0 && paar==0 && pa==0)//尽量满足
                {
                    priority_queue<Node> tmp;
                    priority_queue<Node> tmp2;
                    int cnt=0;
                    while(!pq.empty() && cnt<f)
                    {
                        int flag=0;
                        Node x=pq.top();
                        pq.pop();
                        if(x.area==na)
                        {
                            for(auto tt:x.mp)
                            {
                                if(tt.second==paa)
                                {
                                    flag=1; break;
                                }
                            }
                            if(flag==0)
                            {
                                cout<<x.id<<" ";
                                apply[a].insert(x.area);
                                x.tasksum++;
                                num++;
                                x.mp[num]=a;
                                cnt++;
                                pq.push(x);
                            }
                            else tmp2.push(x);
                        }
                        else tmp.push(x);
                    }
                    while(!tmp2.empty() && cnt<f)
                    {
                        Node x=tmp2.top();
                        tmp2.pop();
                        apply[a].insert(x.area);
                        cout<<x.id<<" ";
                        x.tasksum++;
                        num++;
                        x.mp[num]=a;
                        cnt++;
                        tmp2.push(x);
                    }
                    while(cnt<f)
                    {
                        cout<<0<<" ";
                        cnt++;
                    }
                    while(!tmp.empty())
                    {
                        Node y=tmp.top();
                        pq.push(y);
                        tmp.pop();
                    }
                    while(!tmp2.empty())
                    {
                        Node y=tmp2.top();
                        pq.push(y);
                        tmp2.pop();
                    }
                }
                else if(Area[na].size()>0 && paar==1 && pa>0)//有计算任务亲和性要求，必须和编号为pa的应用的计算任务在同一个可用区运行；
                {
                    priority_queue<Node> tmp;
                    int cnt=0;
                    if(apply[pa].size()==0)
                    {
                        while(cnt<f)
                        {
                            cout<<0<<" ";
                            cnt++;
                        }
                        cout<<endl;
                        continue;
                    }
                    while(!pq.empty() && cnt<f)
                    {
                        int flag=0;
                        Node x=pq.top();
                        pq.pop();
                        if(apply[pa].count(x.area))
                        {
                            if(x.area==na)
                            {
                                for(auto tt:x.mp)
                                {
                                    if(tt.second==paa)
                                    {
                                        flag=1; break;
                                    }
                                }
                                if(flag==0)
                                {
                                    cout<<x.id<<" ";
                                    apply[a].insert(x.area);
                                    x.tasksum++;
                                    num++;
                                    x.mp[num]=a;
                                    cnt++;
                                    pq.push(x);
                                }
                                else tmp.push(x);
                            }
                            else tmp.push(x);
                        }
                        else tmp.push(x);
                    }
                    while(cnt<f)
                    {
                        cout<<0<<" ";
                        cnt++;
                    }
                    while(!tmp.empty())
                    {
                        Node y=tmp.top();
                        pq.push(y);
                        tmp.pop();
                    }
                }
                else if(Area[na].size()>0 && paar==0 && pa>0)//尽量满足
                {
                    priority_queue<Node> tmp;
                    priority_queue<Node> tmp2;
                    int cnt=0;
                    if(apply[pa].size()==0)
                    {
                        while(cnt<f)
                        {
                            cout<<0<<" ";
                            cnt++;
                        }
                        cout<<endl;
                        continue;
                    }
                    while(!pq.empty() && cnt<f)
                    {
                        int flag=0;
                        Node x=pq.top();
                        pq.pop();
                        if(apply[pa].count(x.area))
                        {
                            if(x.area==na)
                            {
                                for(auto tt:x.mp)
                                {
                                    if(tt.second==paa)
                                    {
                                        flag=1; break;
                                    }
                                }
                                if(flag==0)
                               {
                                    cout<<x.id<<" ";
                                    apply[a].insert(x.area);
                                    x.tasksum++;
                                    num++;
                                    x.mp[num]=a;
                                    cnt++;
                                    pq.push(x);
                                }
                                else tmp2.push(x);
                            }
                            else tmp.push(x);
                        }
                        else tmp.push(x);
                    }
                    while(!tmp2.empty() && cnt<f)
                    {
                        Node x=tmp2.top();
                        tmp2.pop();
                        cout<<x.id<<" ";
                        apply[a].insert(x.area);
                        x.tasksum++;
                        num++;
                        x.mp[num]=a;
                        cnt++;
                        tmp2.push(x);
                    }
                    while(cnt<f)
                    {
                        cout<<0<<" ";
                        cnt++;
                    }
                    while(!tmp.empty())
                    {
                        Node y=tmp.top();
                        pq.push(y);
                        tmp.pop();
                    }
                    while(!tmp2.empty())
                    {
                        Node y=tmp2.top();
                        pq.push(y);
                        tmp2.pop();
                    }
                }
            }
            if(na==0 && paar==1 && pa==0)//没有计算节点亲和性要求 必须满足
            {
                priority_queue<Node> tmp;
                int cnt=0;
                while(!pq.empty() && cnt<f)
                {
                    int flag=0;
                    Node x=pq.top();
                    pq.pop();
                    for(auto tt:x.mp)
                    {
                        if(tt.second==paa)
                        {
                            flag=1; break;
                        }
                    }
                    if(flag==0)
                    {
                        x.tasksum++;
                        num++;
                        apply[a].insert(x.area);
                        x.mp[num]=a;
                        cout<<x.id<<" ";
                        cnt++;
                        pq.push(x);
                    }
                    else tmp.push(x);
                }
                while(cnt<f)
                {
                    cout<<0<<" ";
                    cnt++;
                }
                while(!tmp.empty())
                {
                    Node y=tmp.top();
                    pq.push(y);
                    tmp.pop();
                }
            }
            else if(na==0 && paar==0 && pa==0)//尽量满足
            {
                priority_queue<Node> tmp;
                int cnt=0;
                while(!pq.empty() && cnt<f)
                {
                    int flag=0;
                    Node x=pq.top();
                    pq.pop();
                    for(auto tt:x.mp)
                    {
                        if(tt.second==paa)
                        {
                            flag=1; break;
                        }
                    }
                    if(flag==0)
                    {
                        x.tasksum++;
                        num++;
                        apply[a].insert(x.area);
                        x.mp[num]=a;
                        cout<<x.id<<" ";
                        cnt++;
                        pq.push(x);
                    }
                    else tmp.push(x);
                }
                while(!tmp.empty() && cnt<f)
                {
                    Node x=tmp.top();
                    tmp.pop();
                    cout<<x.id<<" ";
                    apply[a].insert(x.area);
                    x.tasksum++;
                    num++;
                    x.mp[num]=a;
                    cnt++;
                    tmp.push(x);
                }
                while(!tmp.empty())
                {
                    Node y=tmp.top();
                    pq.push(y);
                    tmp.pop();
                }
            }
            else if(na==0 && paar==1 && pa>0)//有计算任务亲和性要求，必须和必须和编号为pa的应用的计算任务在同一个可用区运行；
            {
                priority_queue<Node> tmp;
                int cnt=0;
                if(apply[pa].size()==0)
                {
                    while(cnt<f)
                    {
                        cout<<0<<" ";
                        cnt++;
                    }
                    cout<<endl;
                    continue;
                }
                while(!pq.empty() && cnt<f)
                {
                    int flag=0;
                    Node x=pq.top();
                    pq.pop();
                    if(apply[pa].count(x.area))
                    {
                        for(auto tt:x.mp)
                        {
                            if(tt.second==paa)
                            {
                                flag=1; break;
                            }
                        }
                        if(flag==0)
                        {
                            x.tasksum++;
                            num++;
                            apply[a].insert(x.area);
                            x.mp[num]=a;
                            cout<<x.id<<" ";
                            cnt++;
                            pq.push(x);
                        }
                        else tmp.push(x);
                    }
                    else tmp.push(x);
                }
                while(cnt<f)
                {
                    cout<<0<<" ";
                    cnt++;
                }
                while(!tmp.empty())
                {
                    Node y=tmp.top();
                    pq.push(y);
                    tmp.pop();
                }
            }
            else if(na==0 && paar==0 && pa>0)//尽量满足
            {
                priority_queue<Node> tmp;
                priority_queue<Node> tmp2;
                int cnt=0;
                if(apply[pa].size()==0)
                {
                    while(cnt<f)
                    {
                        cout<<0<<" ";
                        cnt++;
                    }
                    cout<<endl;
                    continue;
                }
                while(!pq.empty() && cnt<f)
                {
                    int flag=0;
                    Node x=pq.top();
                    pq.pop();
                    if(apply[pa].count(x.area))
                    {
                        for(auto tt:x.mp)
                        {
                            if(tt.second==paa)
                            {
                                flag=1; break;
                            }
                        }
                        if(flag==0)
                        {
                            x.tasksum++;
                            num++;
                            apply[a].insert(x.area);
                            x.mp[num]=a;
                            cout<<x.id<<" ";
                            cnt++;
                            pq.push(x);
                        }
                        else tmp2.push(x);
                    }
                    else tmp.push(x);
                }
                while(!tmp2.empty() && cnt<f)
                {
                    Node x=tmp2.top();
                    tmp2.pop();
                    cout<<x.id<<" ";
                    apply[a].insert(x.area);
                    x.tasksum++;
                    num++;
                    x.mp[num]=a;
                    cnt++;
                    tmp2.push(x);
                }
                while(cnt<f)
                {
                    cout<<0<<" ";
                    cnt++;
                }
                while(!tmp.empty())
                {
                    Node y=tmp.top();
                    pq.push(y);
                    tmp.pop();
                }
                while(!tmp2.empty())
                {
                    Node y=tmp2.top();
                    pq.push(y);
                    tmp2.pop();
                }
            }
        }
        cout<<endl;
    }
    return 0;
}
自信的小螺丝钉
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
【CCF-CSP】202203-3 计算资源调度器
qq_46162246的博客
04-21 1395
题目：计算资源调度器 50分代码 #include<bits/stdc++.h> using namespace std; const int N = 1010; int n,m; typedef struct node{ int area;//分区 int id;//节点编号 int task;//任务数量 }node; bool cmp(const node x,const node y){ if(x.task != y.task){ ret
CSP第25次 202203-3 计算资源调度器题解
m0_47917394的博客
04-02 5055
试题编号： 202203-3 试题名称： 计算资源调度器 时间限制： 1.0s 内存限制： 512.0MB 题目链接：CSP第25次 CSP-CCF-202203-3 计算资源调度器 AC代码（C++） 总结
计算资源调度器csp
m0_64652057的博客
03-23 191
直接暴力枚举，对一组任务数为f的输入可看作f次一组任务的输入，遍历所有计算节点，判断其是否满足节点亲和性、任务亲和性、任务反亲和性，满足则加入待选集合res，遍历完一轮后看res是否为空，若为空且paar=1直接输出0继续，paar=0则去掉反亲和性要求再遍历一遍，最后按节点上任务数，节点编号从小到大排序，算出最终放置的节点，并更新相应节点的任务数，节点上的应用集合以及该节点所属可用区的应用集合。
CSP 202203-3 计算资源调度器
匿名用户
06-08 500
CSP
#CCF-计算资源调度器-202203-3
weixin_43828456的博客
04-27 933
得分只有80分，保存后续继续改进。 过滤阶段 在这个阶段，先根据计算任务的要求，过滤出所有满足要求的计算节点。如果不存在这样的计算节点，并且指定了计算任务反亲和性要求，并且计算任务反亲和性要求是尽量满足的， 那么去掉计算任务反亲和性要求，再过滤一次。如果还不存在，就认为该计算任务的要求无法满足，该计算任务无法分配。 排序阶段 在这个阶段，将过滤后的计算节点按照这个方法排序： 选择此时运行计算任务数量最少的计算节点； 选择编号最小的计算节点。 n, m = map(int, input().split()..
ccf-csp202203-3资源调度管理器
Galaxy
09-27 741
ccf-csp202203-3资源调度管理器
CCF-CSP刷题网站推荐（含100分答案）
01-06
CCF刷题网站（100分答案）： C/C++： https://blog.csdn.net/tigerisland45/article/details/54755895 https://blog.csdn.net/richenyunqi/article/details/83385502 （含2019.9月答案，点击题解中的C++超链接可看到...
2019CCF-CSP-J初赛试题与解析.doc
10-08
2019CCF-CSP-J初赛试题与解析，提供给需要复习和练习的学生和家长老师等 2019CCF-CSP-J初赛试题与解析，提供给需要复习和练习的学生和家长老师等 2019CCF-CSP-J初赛试题与解析，提供给需要复习和练习的学生和家长...
CCF-CSP必学知识
05-22
有关CCF的CSP认证 一、CSP认证考点的知识要求 在数据结构中，线性表是基础，树是常考点，集合和映射要夕纪学。 背包问题（动态规划） 考试要求 二、考试题型 第一题：一般为水题，把C学扎实便可以过 第二题：...
CCF-CSP-and-PAT-solution:CCF CSP和PAT考试题解（使用C++14语法）
04-17
CCF CSP 考试和 PAT 顶级甲级乙级考试题解本仓库是书籍《算法详解（C++11 语言描述）》（预计 2021 年 5 月左右出版）的配套仓库，主要负责更新 CCF CSP 和 PAT 顶级甲级乙级题解代码。由于 CCF CSP 和 PAT 考试都已...
CCF-CSP认证历年真题
03-05
这是CSP考试认证的历年真题总结，方便查阅与复习。大家复习时可以拿来做参考。
CCF CSP（CCF计算机软件能力认证）&& CCSP_pdf-2021.01.10.rar
01-10
CCF CSP（CCF计算机软件能力认证）&& CCSP_pdf-2021.01.10.rar
202203-3 CCF 计算资源调度器 （运用stl容器模拟 满分题解）
一只可爱的小猴子的博客
09-15 1372
所以可以建立一个unordered_map>,记录每个编号的计算任务在哪些计算节点上。所以可以建立unordered_map 记录每个节点有几个计算任务。，我一开始没有想的很清楚，就开始写，写出来的代码很长很臭，调试特别慢。计算任务反亲和性要求不能和指定应用的计算任务在同一个计算节点。将所有满足要求的节点存储下来，选择最优节点作为计算节点。筛选时需要选择此时运行计算任务数量最少的计算节点。的话，真的不是特别难，只是简单的模拟就能实现。
CSP 202203-3计算资源调度器
qq_44668088的博客
05-30 826
问题分析： 根据题目描述，可以确定一个可用区可以包含很多节点，每个节点只在一个可用区。而且由于可用区和节点数都小于等于1000，比较小。所以可以按照下面的形式定义可用区以及节点。因为任务编号比较大，为了方便起见，采用map来存储每个可用区及节点中的任务信息。 map<int,int> region[1005];//可用区中的任务信息。 struct Node//节点 { int r; // 所属可用区 int cnt; map<int,int> vis;//该节点下的任务 i
CCF-CSP 25次 第三题【计算资源调度器】
QZZ_PP的博客
09-04 429
这种题题面很长要迅速提取有效信息，可以根据后面的数据范围逐个的写，这样更容易理解题目，再就是选对数据结构很关键，再加上一点复杂的逻辑思维，基本可以满分。开始用的优先队列，做对20分后发现怎么也做不了了，其实就是简单的数组晒大小就完了，所有选对数据结构对后面的影响很大。
CCF-CSP 202203-3 计算资源调度器 满分代码全篇暴力
一个努力练习代码的小菜鸟的博客
06-10 624
if else的大嵌套第25次的csp的其他代码：链接代码如下：
[CSP]计算资源调度器CCF认证真题
AF_帆的技术成长日记
09-23 608
【题目背景】西西艾弗岛上兴建了一批数据中心，建设了云计算资源平台。小C是主管西西艾弗云开发的工程师。西西艾弗云中有大量的计算节点，每个计算节点都有唯一编号。西西艾弗云分为多个可用区，每个计算节点位于一个特定的可用区。一个可用区中可以有多个计算节点。西西艾弗云中运行的计算任务分为不同的应用，每个计算任务都有一个应用与之对应，一个应用中可能包括多个计算任务。每个计算任务由一个特定的计算节点执行，下文中计算任务“运行在某可用区上”意即“运行在某可用区的计算节点上”。
csp-202203
m0_58642116的博客
09-06 476
csp简单题解
CSP认证-出行计划、计算资源调度器
qq_51539256的博客
12-31 262
CSP认证题解
python小中大ccf-csp
最新发布
05-29
CCF-CSP是由中国计算机学会（CCF）主办的全国计算机等级考试，其中小学生组（Junior）是面向初中生，中学生组（Senior）是面向高中生，大学生组（Professional）是面向大学生及以上人群。而Python是一种高级编程语言...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值