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;


public class test01 {
    static TreeSet 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();
        
        System.out.println("-------------------");
        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[i][0] + " " + arr[i][1] + " " + arr[i][2]);
        }
		//初始化TreeSet
        recursion(arr, 0, temp, arr[0][0], 1);
        recursion(arr, 1, temp, arr[0][1], 1);
        recursion(arr, 2, temp, arr[0][2], 1);
        //打印TreeSet中第一个值（最小值）
        System.out.println("-------------------");
        System.out.println(intSet.first());

    }
 

    
    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);
        }
    }
}