动态规划第二讲：一个数组，找出一组不相邻的数字，使找出的数字的和最大

一组数字，找出一组不相邻的数字，使最后的和最大。
在一个数组arr中，找出一组不相邻的数字，使得最后的和最大。

分别用递归解法和动态规划解法

package com.study.dynamicprogromming;

/**
 * @date 2020/7/27
 * 一个数组，找出一组不相邻的数字，使最后的和最大，并返回最大值：
 * 例如：
 * {1, 2, 4, 1, 7, 8, 3}
 * 返回： 15
 */
public class Demo2 {

    public static void main(String[] args) {
        int[] values = {1, 2, 4, 1, 7, 8, 3};

        long startTime = System.nanoTime();
        int recursionOpt = recursionOpt(values.length - 1, values);
        long endTime = System.nanoTime();
        System.out.println(recursionOpt);
        System.out.println("本次递归计算耗时：" + (endTime - startTime) / 1000000 + " ms");

        startTime = System.nanoTime();
        int dpOpt = dynamicProgrammingOpt(values);
        endTime = System.nanoTime();
        System.out.println(dpOpt);
        System.out.println("本次动态规划计算耗时：" + (endTime - startTime) / 1000000 + " ms");

    }

    public static int recursionOpt(int index, int[] values) {

        if (index == 0) return values[index];
        if (index == 1) return Math.max(values[0], values[1]);

        return Math.max(recursionOpt(index - 1, values), values[index] + recursionOpt(index - 2, values));
    }

    public static int dynamicProgrammingOpt(int[] values) {
        int[] opts = new int[values.length];
        opts[0] = values[0];
        opts[1] = Math.max(values[0], values[1]);

        for (int i = 2; i < values.length; i++) {
            opts[i] = Math.max(opts[i - 1], opts[i - 2] + values[i]);
        }
        return opts[values.length - 1];
    }
}