最优策略组合下的总的系统消耗资源数

系列文章目录

---

前言

本人最近再练习算法，所以会发布一些解题思路，希望大家多指教

一、题目描述

在通信系统中有一个常见的问题是对用户进行不同策略的调度，会得到不同系统消耗的性能。假设由N个待串行用户，每个用户可以使用A/B/C三种不同的调度策略，不同的策略会消耗不同的系统资源。请你根据如下规则进行用户调度，并返回总的消耗资源数。

规则：

1. 相邻的用户不能使用相同的调度策略。例如：第一个用户使用A策略 则第二个用户只能使用B和C策略；
2. 对单的用户而言，不同的调度策略对系统资源的消耗可以规划后抽象为数值；例如：某用户分别使用ABC策略的系统消耗，分别为15 8 17；
3. 每个用户依次选择当前所能选择的对系统资源消耗最少的策略，局部最优，如果有多个满足要求的策略，选最后一个。

二、输入描述

第一行表示用户个数N。
接下来表示每一行表示一个用户分别使用三个策略的资源消耗，resA resB resC。

三、输出描述

最优策略组合下的总的系统消耗资源数。

四、java代码

//解法一
public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            List<Integer> collect = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());
            map.put(i, collect);
        }
        //初始化总和
        int total = 0;
        //记录前一个用户使用的策略
        int pre = 0;
        boolean isFirst = true;
        for(Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
            //获取策略集合
            List<Integer> value = entry.getValue();
            //根据上一个用户选择的策略，将当前用户的对应位置的策略位置置为-1
            if(!isFirst){
                value.set(pre, -1);
            }
            boolean flag = false;
            //遍历策略集合，获取当前消耗能量最少，且和上一个用户使用策略不同的策略
            for (int i = 0; i < value.size() -1; i++) {
                if(i == 0 && value.get(0) == -1) continue;
                for (int j = i+1; j < value.size(); j++) {
                    if(value.get(j) == -1) continue;
                    //找到比当前策略性能更优的，则以更优的策略为基点，依次向后比较
                    if(value.get(i) >= value.get(j)) {
                        i = j-1;
                        pre = j;
                        flag = true;
                        break;
                    }
                }
                //如果向后遍历未找到比当前策略消耗能量小的，则当前策略为最优策略，直接跳出外层的for循环
                if(!flag){
                    pre = i;
                    break;
                }
            }
            total += value.get(pre);
            //标识下一个用户不是第一个用户
            isFirst = false;
        }
        System.out.println(total);
    }

//解法二：
	public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = Integer.parseInt(sc.nextLine());
        int[][] arr = new int[N][3];
        for (int i = 0; i < N; i++) {
            arr[i] = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        }
        int preIndex = -1;
        int sum = 0;
        for (int i = 0; i < N; i++) {
        	//如果上一个用户使用了第一个策略，则直接从第二个策略开始获取最小能量消耗值
            int k = preIndex == 0 ? 1 : 0;
            int index = k;
            int min = arr[i][k];
            //向后遍历进行比较，获取最小能量消耗值
            for (int j = k+1; j < 3; j++) {
                if (preIndex == j) continue;
                if (min >= arr[i][j]) {
                    min = arr[i][j];
                    index = j;
                }
                if(j == 2) {
                    sum += min;
                    preIndex = index;
                }
            }
        }
        System.out.println(sum);
    }

五、测试用例

输入：
5
15 14 16
10 21 12
2 4 9
16 14 21
17 13 16
输出：
57
求和过程：14+10+4+16+13 = 57