处理器问题
题目描述
某公司研发了一款高性能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。\n编号0-3的处理器处于一个链路，编号4-7的处理器处于另外一个链路。
处理器编号唯一，且不存在相同编号处理器。
输入描述
输入包含可用的处理器编号数组array，以及任务申请的处理器数量num两个部分。
第一行为array，第二行为num。例如：
[0, 1, 4, 5, 6, 7] 1
表示当前编号为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]]
| 输入 | [0, 1, 4, 5, 6, 7] 1 |
| 输出 | [[0], [1]] |
| 说明 | 根据第一条亲和性调度原则，在剩余两个处理器的链路（0, 1, 2, 3）中选择处理器。 由于只有0和1可用，则返回任意一颗处理器即可。 |
| 输入 | [0, 1, 4, 5, 6, 7] 4 |
| 输出 | [[4, 5, 6, 7]] |
| 说明 | 根据第三条亲和性调度原则，必须选择同一链路剩余可用的处理器数量为4个的环 |
解析
可以把亲和性调度原则封装为一个Map集合。如下
Java源码示例
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class T23 {
public static void main(String[] args) {
String input = "0,1,4,5,6,7";
int applyNum = 1;
String[] cArr = input.split(",");
List<Integer> link1 = new ArrayList<Integer>();
List<Integer> link2 = new ArrayList<Integer>();
for (String item : cArr) {
int num = Integer.parseInt(item);
if (num <= 3) {
link1.add(num);
} else {
link2.add(num);
}
}
System.out.println(link1);
System.out.println(link2);
/**
* -如果申请处理器个数为1，则选择同一链路，剩余可用的处理器数量为1个的最佳，其次是剩余3个的为次佳，然后是剩余2个，最后是剩余4个。
* -如果申请处理器个数为2，则选择同一链路剩余可用的处理器数量2个的为最佳，其次是剩余4个，最后是剩余3个。
* -如果申请处理器个数为4，则必须选择同一链路剩余可用的处理器数量为4个。 -如果申请处理器个数为8，则申请节点所有8个处理器。
*/
Map<Integer, Integer[]> map = new HashMap<Integer, Integer[]>();
Integer[] pri1 = { 1, 3, 2, 4 };
Integer[] pri2 = { 2, 4, 3 };
Integer[] pri4 = { 4 };
Integer[] pri8 = { 8 };
map.put(1, pri1);
map.put(2, pri2);
map.put(4, pri4);
map.put(8, pri8);
switch (applyNum) {
case 1:
Integer[] pri = map.get(1);
for (int i = 0; i < pri.length; i++) {
if (link1.size() == link2.size()) {
// 两个一样多，那么就任意取一个
List<List<Integer>> result = new ArrayList<>();
for (Integer item : link1) {
List<Integer> itemList = new ArrayList<>();
itemList.add(item);
result.add(itemList);
}
for (Integer item : link2) {
List<Integer> itemList = new ArrayList<>();
itemList.add(item);
result.add(itemList);
}
System.out.println(result);
break;
}
if (link1.size() == pri[i]) {
// 输出link1内的内容
List<List<Integer>> result = new ArrayList<>();
for (Integer item : link1) {
List<Integer> itemList = new ArrayList<>();
itemList.add(item);
result.add(itemList);
}
System.out.println(result);
break;
}
if (link2.size() == pri[i]) {
// 输出link1内的内容
List<List<Integer>> result = new ArrayList<>();
for (Integer item : link2) {
List<Integer> itemList = new ArrayList<>();
itemList.add(item);
result.add(itemList);
}
System.out.println(result);
break;
}
}
break;
case 2:
Integer[] priTwo = map.get(2);
for (int i = 0; i < priTwo.length; i++) {
if (link1.size() == link2.size()) {
// 随机取出2个
ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
result.addAll(getRandom(link1, applyNum));
result.addAll(getRandom(link2, applyNum));
System.out.println(result);
break;
}
if(link1.size()==priTwo[i]){
ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
result.addAll(getRandom(link1, applyNum));
System.out.println(result);
break;
}
if(link2.size()==priTwo[i]){
ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
result.addAll(getRandom(link2, applyNum));
System.out.println(result);
break;
}
}
break;
case 4:
if(link1.size()==link2.size()&&link1.size()==4){
ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
List<Integer> itemList = new ArrayList<>();
itemList.addAll(link1);
result.add(itemList);
itemList = new ArrayList<>();
itemList.addAll(link2);
result.add(itemList);
System.out.println(result);
break;
}
if (link1.size() == 4) {
ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
List<Integer> itemList = new ArrayList<>();
itemList.addAll(link1);
result.add(itemList);
System.out.println(result);
break;
}
if (link2.size() == 4) {
ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
List<Integer> itemList = new ArrayList<>();
itemList.addAll(link2);
result.add(itemList);
System.out.println(result);
}
break;
case 8:
if (link1.size() == 4 && link2.size() == 4) {
ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
List<Integer> itemList = new ArrayList<>();
itemList.addAll(link1);
itemList.addAll(link2);
result.add(itemList);
System.out.println(result);
}
break;
default:
break;
}
}
// 随机产生随机下标
static List<List<Integer>> getRandom(List<Integer> link, int num) {
List<List<Integer>> resultList = new ArrayList<>();
if (link.size() == num) {
resultList.add(link);
} else if (link.size() > num) {
// 长度是4 取2个 长度4取3个
// 长度3取2个
if (link.size() == 4 && num == 2) {
List<Integer> items = new ArrayList<>();
items.add(link.get(0));
items.add(link.get(1));
resultList.add(items);
items = new ArrayList<>();
items.add(link.get(0));
items.add(link.get(2));
resultList.add(items);
items = new ArrayList<>();
items.add(link.get(0));
items.add(link.get(3));
resultList.add(items);
items = new ArrayList<>();
items.add(link.get(1));
items.add(link.get(2));
resultList.add(items);
items = new ArrayList<>();
items.add(link.get(1));
items.add(link.get(3));
resultList.add(items);
items = new ArrayList<>();
items.add(link.get(2));
items.add(link.get(3));
resultList.add(items);
} else if (link.size() == 3 && num == 2) {
List<Integer> items = new ArrayList<>();
items.add(link.get(0));
items.add(link.get(1));
resultList.add(items);
items = new ArrayList<>();
items.add(link.get(0));
items.add(link.get(2));
resultList.add(items);
items = new ArrayList<>();
items.add(link.get(1));
items.add(link.get(2));
resultList.add(items);
}
}
return resultList;
}
}
