贪心算法

贪心算法思想：不从整体最优上加以考虑，它所做出的选择只是在某种意义上的局部最优选择，当然希望贪心算法得到的最终结果也是整体最优的；

贪心算法性质：指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到；

最优装载问题

（1）问题描述：有一批集装箱要装上一艘载重量为 tatol 的轮船，其中集装箱 index 的重量为 weight。最优装载问题要求在装载体积不受限制的情况下，将尽可能多的集装箱装上轮船【目前只考虑一个物品只有一个】，store 数组存放物品是否装载 1：存放  0：不存放；

（2）最优装载问题可用贪心算法求解，采用重量最轻者先装的贪心选择策略，可产生最优装载问题的最优解，算法如下：

public class ExcellentLoading {

    /**
     * 轮船的最大容量
     */
    private static Integer total = 0;

    /**
     * 轮船装完物品，剩余重量
     */
    private static Integer residueTotal = 0;

    /**
     * 装入的物品个数
     */
    private static Integer num = 0;

    /**
     * 物品重量数组
     */
    private static Integer[] weight;

    /**
     * 物品存放数组【1：存放  0：不存放】
     */
    private static Integer[] store;

    /**
     * 初始化数据
     */
    private static void initData() {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入轮船的总重量:");
        total = input.nextInt();
        System.out.print("请输入要装入的物品个数:");
        num = input.nextInt();
        System.out.println("请输入各物品的重量:");
        weight = new Integer[num];
        store = new Integer[num];
        for (int i = 0; i < weight.length; i++) {
            weight[i] = input.nextInt();    //每个物品的重量
            store[i] = 0;                   //初始化物品都不存放
        }
    }

    /**
     * 按物品重量由小到大升序排序，同时调整物品序号
     */
    private static void weightSort() {
        Integer change = 1;
        Integer temp;
        for (int i = 0; i < weight.length - 1 && change == 1; i++) {
            change = 0;
            for (int j = 0; j < weight.length - 1 - i; j++) {
                if (weight[j] > weight[j + 1]) {
                    // 交换重量数组
                    temp = weight[j];
                    weight[j] = weight[j + 1];
                    weight[j + 1] = temp;

                    change = 1; //避免不必要的排序操作
                }
            }
        }
    }

    /**
     * 统计最优装载
     */
    private static void excellentLoading() {
        residueTotal = total;
        for (int i = 0; i < weight.length && weight[i] <= residueTotal; i++) {
            store[i] = 1;     // 轮船存放物品
            residueTotal = residueTotal - weight[i];  // 轮船剩余重量
        }
    }

    /**
     * 输出函数
     */
    private static void print() {
        System.out.println("轮船最大容量: total = " + total + "，轮船剩余容量: residueTotal = " + residueTotal);
        System.out.println("排序完物品数组: ");
        Stream.of(weight).forEach(element -> System.out.print(element + " "));
        System.out.println();
        System.out.println("物品存放数组: ");
        Stream.of(store).forEach(element -> System.out.print(element + " "));
        System.out.println();
    }

    public static void main(String[] args) {
        // 初始化数据
        initData();
        // 排序【按重量由小到大】
        weightSort();
        // 统计最优装载
        excellentLoading();
        // 输出
        print();
    }

}

（3）输入输出结果：

请输入轮船的总重量:20
请输入要装入的物品个数:6
请输入各物品的重量:
1
4
8
6
9
3
轮船最大容量: total = 20，轮船剩余容量: residueTotal = 6
排序完物品数组: 
1 3 4 6 8 9 
物品存放数组: 
1 1 1 1 0 0 

（4）总结：贪心算法重在考虑局部最优解，整体最优解即在众多个局部最优解中选择一个最优的解；