动态规划

最优收入问题

public static void main(String[] args) {
        int[][] nums = {{0, 0}, {1, 4}, {3, 5}, {0, 6}, {4, 7}, {3, 8}, {5, 9}, {6, 10}, {8, 11}};//表示时间段
        int[] money = {0, 5, 1, 8, 4, 6, 3, 2, 4};//表示收入
        int[] opt = new int[nums.length];
        int[] prev = new int[nums.length];

        for (int i = 1; i < nums.length; i++) {
            for (int j = i - 1; j >= 0; j--) {
                if (nums[j][1] <= nums[i][0]) {
                    prev[i] = j;//这个prev方法存在一定的问题，比如前面有两个时间段可以选的话。但是题意不完全，所有只按照视频给出的题意。
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(prev));
        for (int i = 1; i < opt.length; i++) {
            opt[i] = Math.max(opt[i - 1], money[i] + opt[prev[i]]);
        }
        System.out.println(opt[opt.length-1]);
    }

结果：

[0, 0, 0, 0, 1, 0, 2, 3, 5]
13

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

public static void main(String[] args) {
        int nums[] = {1, 2, 4, 1, 7, 8, 3};
        int opt[] = new int[nums.length];
        System.out.println(getMaxSumDp(nums));
    }

    //    递归形式
    private static int getMaxSum(int[] nums, int i) {
        if (i == 0) {
            return nums[0];
        } else if (i == 1) {
            return Math.max(nums[0], nums[1]);
        }
        return Math.max(getMaxSum(nums, i - 1), getMaxSum(nums, i - 2) + nums[i]);
    }

    //    动态规划形式
    private static int getMaxSumDp(int[] nums) {
        int[] opt = new int[nums.length];
        opt[0] = nums[0];
        opt[1] = Math.max(nums[0], nums[1]);
        for (int i = 2; i < nums.length; i++) {
            opt[i] = Math.max(opt[i - 2] + nums[i], opt[i - 1]);
        }
        return opt[opt.length-1];
    }

给定一个正整数s, 判断一个数组arr中，是否有一组数字加起来等于s。

public static void main(String[] args) {
        int[] nums = {3, 34, 4, 12, 5, 2};
        System.out.println(getSubSetBp(nums, 9));
    }

    //    递归
    private static boolean getSubSet(int[] nums, int index, int value) {
        if (value == 0) {
            return true;
        }
        if (index == 0) {
            return nums[0] == value;
        }
        if (nums[index] > value) {
            return getSubSet(nums, index - 1, value);
        }

        return getSubSet(nums, index - 1, value - nums[index]) || getSubSet(nums, index - 1, value);
    }

    //    动态规划
    private static boolean getSubSetBp(int[] nums, int value) {
        boolean[][] subSet = new boolean[nums.length][value + 1];
        for (int i = 0; i < nums.length; i++) {
            subSet[i][0] = true;
        }
        subSet[0][nums[0] > value ? 0 : nums[0]] = true;

        for (int i = 1; i < nums.length; i++) {
            for (int j = 1; j < subSet[0].length; j++) {
                if (nums[i] > value) {
                    subSet[i][j] = subSet[i - 1][j];
                } else {
                    subSet[i][j] = (j - nums[i] >= 0 && subSet[i - 1][j - nums[i]]) || subSet[i - 1][j];
                }
            }
        }
        return subSet[subSet.length - 1][subSet[0].length - 1];
    }