202203-3 CCF 计算资源调度器 （运用stl容器模拟 满分题解）

问题描述

计算资源调度器 题目链接

解题思路

题目很长，千万不要急着写，我一开始没有想的很清楚，就开始写，写出来的代码很长很臭，调试特别慢
可以通读一遍题目，然后将要用到的数据结构先列出来
题目的主要意思就是帮每一个任务找一个最合适的计算节点
其中计算节点可能需要满足一些要求
那简单的思路就是枚举每个计算节点，看该节点是否满足要求
将所有满足要求的节点存储下来，选择最优节点作为计算节点
将要用到的数据结构先列出来，例如：
计算节点亲和性需要满足该节点在指定区
所以可以建立一个数组记录每个节点在哪个区

计算任务反亲和性要求不能和指定应用的计算任务在同一个计算节点
所以可以建立一个unordered_map>,记录每个编号的计算任务在哪些计算节点上

筛选时需要选择此时运行计算任务数量最少的计算节点
所以可以建立unordered_map 记录每个节点有几个计算任务

其实这个题目思路理清楚了，并熟练运用stl容器的话，真的不是特别难，只是简单的模拟就能实现

代码实现

#include 
#include 
#include 
#include 
#include 

using namespace std;

const int N = 1010;
typedef pair <int, int> PII;

int n, m; //计算节点数，分区数
int adr[N]; //存储每个节点在哪个区
vector <int> area[N]; //存储每个区有哪些节点
unordered_map <int, int> tasksum; //每个计算节点有多少个计算任务
unordered_map <int, vector <int>> id; //每个应用编号的任务在哪些计算节点上

bool cknq(int nodeid, int areaid) //是否满足计算节点亲和性
{
    if (areaid == 0) return true;
    bool flag = false;
    for (auto x : area[areaid])
    {
        if (nodeid == x)
        {
            flag = true;
            break;
        }
    }
    return flag;
}

bool ckrq(int nodeid, int apid) // 是否满足计算任务亲和性
{
    if (apid == 0) return true;
    bool flag = false;
    for (auto x : id[apid])
    {
        if (adr[nodeid] == adr[x])
        {
            flag = true;
            break;
        }
    }
    return flag;
}

bool cknrq(int nodeid, int apid) //是否满足计算任务非亲和性
{
    if (apid == 0) return true;
    bool flag = true;
    for (auto x : id[apid])
    {
        if (x == nodeid)
        {
            flag = false;
            break;
        }
    }
    return flag;
}

int main()
{
    cin >> n >> m;

    for (int i = 1; i <= n; i ++)
    {
        int x;
        cin >> x;
        area[x].push_back(i); //x分区内有计算节点i
        adr[i] = x; //i计算节点在x分区
    }

    int g;
    cin >> g; //g组询问
    
    //任务数目， 应用编号， 节点亲和，任务亲和， 任务非亲和， 一定任务亲和
    int tnum, apid, nq, tq, ntq, mustq;

    while (g --)
    {
        cin >> tnum >> apid >> nq >> tq >> ntq >> mustq;
        
        //对于tnum个计算任务注意分配空间
        for (int p = 0; p < tnum; p ++)
        {
            vector <int> res, t;
            for (int i = 1; i <= n; i ++)
            {
                if (cknq(i, nq) && ckrq(i, tq) && cknrq(i, ntq)) res.push_back(i); //一定要满足非任务亲和
                if (!mustq && ckrq(i, tq) && cknq(i, nq)) t.push_back(i); //不满足非任务亲和
            }
            if (res.size() == 0 && !mustq) res = t; //如果没有答案，就不要任务非亲和
            if (res.size() == 0) cout << 0 << " "; //没有可分配的节点，答案为0
            else
            {
                vector <PII> node;
                for (auto x : res) node.push_back({tasksum[x], x}); //将{节点运行任务的数目，节点编号}存储排序
                sort(node.begin(), node.end()); //node[0]一定是任务数最少，且编号最小的
                cout << node[0].second << " ";
                tasksum[node[0].second] ++;
                id[apid].push_back(node[0].second);
            }
        }
        puts(" ");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109