华为机试真题 C++ 实现【处理器问题】

题目

题目描述

某公司研发了一款高性能AI处理器。每台物理设备具备8颗AI处理器，编号分别为0、1、2、3、4、5、6、7。

编号0-3的处理器处于同一个链路中，编号4-7的处理器处于另外一个链路中，不同链路中的处理器不能通信。

现给定服务器可用的处理器编号数组array，以及任务申请的处理器数量num，找出符合下列亲和性调度原则的芯片组合。

如果不存在符合要求的组合，则返回空列表。

亲和性调度原则：

-如果申请处理器个数为1，则选择同一链路，剩余可用的处理器数量为1个的最佳，其次是剩余3个的为次佳，然后是剩余2个，最后是剩余4个。

-如果申请处理器个数为2，则选择同一链路剩余可用的处理器数量2个的为最佳，其次是剩余4个，最后是剩余3个。

-如果申请处理器个数为4，则必须选择同一链路剩余可用的处理器数量为4个。

-如果申请处理器个数为8，则申请节点所有8个处理器。

提示：

1. 任务申请的处理器数量只能是1、2、4、8。
2. 编号0-3的处理器处于一个链路，编号4-7的处理器处于另外一个链路。
3. 处理器编号唯一，且不存在相同编号处理器。

输入描述

输入包含可用的处理器编号数组array，以及任务申请的处理器数量num两个部分。

第一行为array，第二行为num。例如：

[0, 1, 4, 5, 6, 7]

表示当前编号为0、1、4、5、6、7的处理器可用。任务申请1个处理器。

0 <= array.length <= 8

0 <= array[i] <= 7

num in [1, 2, 4, 8]

输出描述

输出为组合列表，当array=[0，1，4，5，6，7]，num=1 时，输出为[[0], [1]]。

示例1 输入输出示例仅供调试，后台判题数据一般不包含示例

输入

[0, 1, 4, 5, 6, 7]

1

输出

[[0], [1]]

说明

根据第一条亲和性调度原则，在剩余两个处理器的链路（0, 1, 2, 3）中选择处理器。

由于只有0和1可用，则返回任意一颗处理器即可。

思路

逻辑处理

#include <bits/stdc++.h>

using namespace std;

vector<int> split(string str) {
    vector<int> res;
    stringstream ss(str);
    while(getline(ss, str, ',')) {
        res.push_back(stoi(str));
    }
    return res;
}

int main(){
    string str;
    getline(cin, str);
    int val;
    cin >> val;
    vector<int> vec = split(str.substr(1,str.size()-2));
    int v1 = 0;
    int v2 = 0;
    vector<int> vis(8);
    for(int i = 0; i < vec.size(); i++) {
        if(vec[i]<4) {
            v1++;
        }else{
            v2++;
        }
        vis[vec[i]] = 1;
    }

    vector<vector<int>> ans;
    if (val == 1) {
        //申请1个处理器
        int state = 0;
        //亲和度判断
        if (v1 == 1 || v2 == 1) state = 1;
        else if (v1 == 3 || v2 == 3) state = 3;
        else if (v1 == 2 || v2 == 2) state = 2;
        else if (v1 == 4 || v2 == 4) state = 4;
        if (v1 == state) {
            for (int i = 0; i < 4; i++) {
                if (vis[i] == 1) {
                    vector<int> tmp;
                    tmp.push_back(i);
                    ans.push_back(tmp);
                }
            }
        }
        if (v2 == state) {
            for (int i = 4; i < 8; i++) {
                if (vis[i] == 1) {
                    vector<int> tmp;
                    tmp.push_back(i);
                    ans.push_back(tmp);
                }
            }
        }
    } else if (val == 2) {
        //申请2个处理器
        int state = 0;
        if (v1 == 2 || v2 == 2) state = 2;
        else if (v1 == 4 || v2 == 4) state = 4;
        else if (v1 == 3 || v2 == 3) state = 3;
        if (v1 == state) {
            for (int i = 0; i < 4; i++) {
                for (int j = i + 1; j < 4; j++) {
                    if (i != j && vis[i] == 1 && vis[j] == 1) {
                        vector<int> tmp;
                        tmp.push_back(i);
                        tmp.push_back(j);
                        ans.push_back(tmp);
                    }
                }
            }
        }
        if (v2 == state) {
            for (int i = 4; i < 8; i++) {
                for (int j = i + 1; j < 8; j++) {
                    if (i != j && vis[i] == 1 && vis[j] == 1) {
                        vector<int> tmp;
                        tmp.push_back(i);
                        tmp.push_back(j);
                        ans.push_back(tmp);
                    }
                }
            }
        }
    } else if (val == 4) {
        cout<<"[";
        //申请4个处理器
        if (v1 == 4) {
            cout<<"[0,1,2,3]";
        }
        if (v2 == 4) {
            if(v1 == 4) cout<<",";
            cout<<"[4,5,6,7]";
        }
        cout << "]";
    } else if (val == 8) {
        if(vec.size()==8) {
            cout<<"[0,1,2,3,4,5,6,7]";
        }else{
            cout<<"[]";
        }
    }
    cout<<"[";
    int i=0;
    for(auto se:ans) {
        i++;
        cout<<"[";
        for(int i=0;i<se.size();i++) {
            cout<<se[i];
            if(i!=se.size()-1) {
                cout<<",";
            }
        }
        cout<<"]";
        if(i!=ans.size()) {
            cout<<",";
        }
    }
    cout<<"]";
    return 0;
}