CSP 202203-3 计算资源调度器

#include<iostream>

using namespace std;

const int N = 1010,M = 2010; // 节点的数量

int n,m; //计算节点的数目和可用区的数目

struct Node{
    int num; // 数量的记录
    int varflag; // 可用区的标志
    int appl[M];
    /*
    bool operator < (const Node &y) const // 结构体运算符重载
    {
        return num < y.num; //设定按照由小到大排列
    }
    */
}nodes[N];  // 计算节点的编号，使用了排序之后就会变乱。不如每次都跑一次min，找到最小的下标。然后根据这个来跑。

int g;
int f,a,na,pa,paa,paar;
int Min,loc;
int flag;

int main()
{
    cin >> n >> m;
    for(int i=1;i <= n;i++) // 从第一个计算节点开始算起
    {
        cin >> nodes[i].varflag; // 输入可用区上
    }

    cin >> g;
    while(g--)
    {
        cin >> f >> a >> na >> pa >> paa >> paar;
        // 过滤阶段
        // 排序阶段 plus // 放置赋值
        // 并且指定了计算任务反亲和性要求，并且计算任务反亲和性要求是尽量满足的，
        // 那么去掉计算任务反亲和性要求，再过滤一次。if(no exist && paar != 0) return 0
        //  if(paar == 0) paa = 0; 依然没有答案，就return 0;

        // 要不要在这，把可用区过滤一下
        int keyongqu[M],len = 0;
        if(pa != 0)// 这个可用区内如果存在，这个可用区的所有都可以满足// 预处理
        {
            for(int i=1;i <= n;i++)
            {
                for(int j=0;j < nodes[i].num;j++)
                {
                    if(nodes[i].appl[j] == pa) // 说明存在亲和的 // 是针对一个
                    {
                        keyongqu[len] = nodes[i].varflag; // 这个会加很多重复的进去
                        len++;
                    }
                }
            }
        }

        flag = 0;
        while(f--)
        {
            Min = M,loc = -1;
            for(int i=1; i <= n;i++)
            {
                if(na != 0) // 对于可用区间有要求
                {
                    if(nodes[i].varflag != na)
                    {
                        continue; // 排除掉这个选项
                    }
                }
                if(paa != 0)
                {
                    int key = 0;
                    for(int j=0;j < nodes[i].num;j++)
                    {
                        if(nodes[i].appl[j] == paa) // 说明有不亲和的
                        {
                            key = 1;
                            break;
                            //continue; // 排除掉这个选项。 这个continue只是对当前这个or循环有用
                        }
                    }
                    if(key == 1)
                        continue;
                }
                if(pa != 0)
                {
                    int key = 0;
                    for(int ll=0; ll < len;ll++)
                    {
                        if(nodes[i].varflag == keyongqu[ll])
                        {
                            key = 1;
                        }
                    }
                    if(key == 0)
                    {
                        continue;
                    }
                }

                if(nodes[i].num < Min)
                {
                    Min = nodes[i].num;
                    loc = i;
                }
            }
            if(loc != -1)
            {
                int nums = nodes[loc].num;
                nodes[loc].num++;
                nodes[loc].appl[nums] = a;
                cout << loc << " ";
            }
            else // 没有找到
            {
                if(paar != 0) cout << "0 ";
                else if(flag == 1)
                {
                    flag = 0; // 重置
                    cout << "0 ";
                }
                else
                {
                    paa = 0;
                    f++; // 再来一次
                    flag = 1;
                    continue;
                }
            }
        }
        cout << endl;
    }


    return 0;
}

/**
20 分的
10 4
1 1 1 1 1 2 2 2 2 2
1
6 2 0 0 0 0

50 分的
10 4
1 1 1 1 1 2 2 2 2 2
2
6 2 0 0 0 0
6 2 2 0 0 0

80 分的
10 4
1 1 1 1 1 2 2 2 2 2
4
6 2 2 0 0 0
6 2 2 0 2 0
6 2 2 0 2 1
6 2 2 1 0 0

*/
/**
 * 自行编写测试样例
 * 题目的样例理解就需要多时
*/