No.3.7

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

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

三、输入描述：

第一行表述用户个数n
接下来每一行表示一个用户分别使用三个策略的系统消耗resA resB resC

四、输出描述：

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

五、示例：

输入

3
15 8 17
12 20 9
11 7 5

输出

24

说明

1号用户使用B策略，2号用户使用C策略，3号用户使用B策略。系统资源消耗：8 + 9 + 7 = 24；

六、输出描述：

所有策略对系统的资源消耗均为正整数，n<1000

参考结果：

package com.groupies.测试;

import java.util.Random;
import java.util.Scanner;
import java.util.TreeSet;

/**
 * @author GroupiesM
 * @date 2022/04/23
 * @introduction
 * 思路：TreeSet自动排序 + 二维数组递归方法
 * 这里用的生成随机数，提交答案时 r.nextInt(30) + 1 改为 in.nextInt() 即可，并且把打印的三行数据去掉
 */
public class test01 {
    static TreeSet<Integer> intSet = new TreeSet();
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int temp = in.nextInt();
        int[][] arr = new int[temp][3];
        Random r = new Random();

        for (int i = 0; i < temp; i++) {
            arr[i][0] = r.nextInt(30) + 1;
            arr[i][1] = r.nextInt(30) + 1;
            arr[i][2] = r.nextInt(30) + 1;
        }
        System.out.println(arr[0][0] + " " + arr[0][1] + " " + arr[0][2]);
        System.out.println(arr[1][0] + " " + arr[1][1] + " " + arr[1][2]);
        System.out.println(arr[2][0] + " " + arr[2][1] + " " + arr[2][2]);

        recursion(arr, 0, temp, arr[0][0], 1);
        recursion(arr, 1, temp, arr[0][1], 1);
        recursion(arr, 2, temp, arr[0][2], 1);
        System.out.println(intSet.first());
        /**
        参考： 7 + 9 + 2 = 18
        	3
			16 7 23
			9 24 7
			10 9 2
			18
        */
    }

    /**
     * 递归方法遍历数组
     * @param arr       数组
     * @param duplicate 上次出现的位置
     * @param leftCount 剩余递归次数
     * @param total 记录当前和
     * @param recursionCount 已递归次数
     * @return
     */
    public static void recursion(int[][] arr, int duplicate, int leftCount, int total, int recursionCount) {
        int left = leftCount - 1;
        if (left == 0) {
            intSet.add(total);
            return;
        }
        if (duplicate == 0) {
            recursion(arr, 1, left, total + arr[recursionCount][1], recursionCount + 1);
            recursion(arr, 2, left, total + arr[recursionCount][2], recursionCount + 1);
        } else if (duplicate == 1) {
            recursion(arr, 0, left, total + arr[recursionCount][0], recursionCount + 1);
            recursion(arr, 2, left, total + arr[recursionCount][2], recursionCount + 1);
        } else if (duplicate == 2) {
            recursion(arr, 0, left, total + arr[recursionCount][0], recursionCount + 1);
            recursion(arr, 1, left, total + arr[recursionCount][1], recursionCount + 1);
        }
    }
}