华为机试真题 Java 实现【处理器问题/ 高性能AI处理器】

题目描述

某公司研发了一款高性能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、2、4、8。

编号0-3的处理器处于一个链路，编号4-7的处理器处于另外一个链路。

处理器编号唯一，且不存在相同编号处理器。

输入描述

输入包含可用的处理器编号数组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]

输出

[[0], [1]]

说明

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

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

个人解法

不保证通过率

package 真题;

import java.util.ArrayList;
import java.util.Arrays;

/**
 *
 */
public class Main {
    public static void main(String[] args) {
        System.out.println(Arrays.deepToString(find(new int[]{0, 1, 2, 3, 6, 7}, 2)));
    }

    public static int[][] find(int[] array, int num) {
        ArrayList<Integer> a1 = new ArrayList<>();
        ArrayList<Integer> a2 = new ArrayList<>();
        int num1 = 0, num2 = 0;
        for (int value : array) {
            if (value > 3) {
                a2.add(value);
                num2++;
            } else {
                a1.add(value);
                num1++;
            }
        }
        int[] q1 = new int[]{1, 3, 2, 4};
        int[] q2 = new int[]{2, 4, 3};
        ArrayList<int[]> list = new ArrayList<>();
        if (num == 8 && num1 + num2 == 8) {
            return new int[][]{{0, 1, 2, 3, 4, 5, 6, 7}};
        }
        if (num == 4) {
            if (num1 == 4) list.add(new int[]{0, 1, 2, 3});
            if (num2 == 4) list.add(new int[]{4, 5, 6, 7});
        }
        if (num == 1)
            for (int value : q1) {
                if (num1 != value && num2 != value) continue;
                if (num1 == value) {
                    for (Integer integer : a1) {
                        list.add(new int[]{integer});
                    }
                }
                if (num2 == value) {
                    for (Integer integer : a2) {
                        list.add(new int[]{integer});
                    }
                }
                break;
            }
        if (num == 2)
            for (int value : q2) {
                if (num1 != value && num2 != value) continue;
                if (num1 == value) {
                    for (int j = 0; j < a1.size() - 1; j++) {
                        for (int k = j + 1; k < a1.size(); k++) {
                            list.add(new int[]{a1.get(j), a1.get(k)});
                        }
                    }
                }
                if (num2 == value) {
                    for (int j = 0; j < a2.size() - 1; j++) {
                        for (int k = j + 1; k < a2.size(); k++) {
                            list.add(new int[]{a2.get(j), a2.get(k)});
                        }
                    }
                }
                break;
            }
        if (!list.isEmpty()) {
            int[][] result = new int[list.size()][list.get(0).length];
            list.toArray(result);
            return result;
        }
        return new int[][]{};
    }
}