动态规划

简介

动态规划遵循一套固定的流程：递归的暴力解法( O(2^n) ) -> 带备忘录的递归解法( O(n) ) -> 非递归的动态规划解法( O(n) )。


「自顶向下」：
	是从上向下延伸，
	都是从一个规模较大的原问题比如说 f(20)，向下逐渐分解规模，直到 f(1) 和 f(2) 触底，然后逐层返回答案。


「自底向上」：
	直接从最底下，最简单，问题规模最小的 f(1) 和 f(2) 开始往上推，直到推到我们想要的答案 f(20)，

动态规划解法

1. 将原问题分解为子问题
    f(0),f(1),f(2)...f(n)

2. 确定状态
    f(n)

3. 确定一些初始状态(边界条件)的值
    f(n)=0

4. 确定状态转移方程（当前子问题值与前一个子问题值的关系）
	f(n) 是一个状态 n，这个状态 n 是由状态 n - 1 和状态 n - 2 相加转移而来，这就是状态转移
	动态规划问题最困难的就是写出状态转移方程。

适合使用动规求解的问题

1. 问题具有最优子结构（问题的最优解所包含的子问题的解也是最优的）

2. 求最优解问题

动态规划1：爬楼梯，求共多少爬法（n为正整数）

/**
 * 方法1：递归（超时）：太多冗余
 */
class Solution1 {
    public static int climbStairs(int n) {
        if(n==1 || n==2)return n;
        return climbStairs(n-1)+climbStairs(n-2);
    }
}


/**
 * 方法2：记忆化递归递归
 *      把每一步的结果存储在 memo 数组之中，每当函数再次被调用，我们就直接从 memo 数组返回结果。
 *
 * 时间复杂度：O(n)，树形递归的大小可以达到 n。
 * 空间复杂度：O(n)，递归树的深度可以达到 n。
 */
class Solution2 {
    public static int climbStairs(int n) {
        int memo[] = new int[n + 1];
        return climb_Stairs(0, n, memo);
    }
    public static int climb_Stairs(int i, int n, int memo[]) {
        if (i > n) {
            return 0;
        }
        if (i == n) {
            return 1;
        }
        if (memo[i] > 0) {
            return memo[i];
        }
        memo[i] = climb_Stairs(i + 1, n, memo) + climb_Stairs(i + 2, n, memo);
        return memo[i];
    }
}

class Solution2 {
    public static int climbStairs(int n) {
        int memo[] = new int[n + 1];
        return climb_Stairs(n, memo);
    }

    public static int climb_Stairs(int n, int memo[]) {
        if (n == 1 || n == 2) return memo[n] = n;
        if (memo[n] > 0) {
            return memo[n];
        }
        return memo[n] = climb_Stairs(n - 1, memo) + climb_Stairs(n - 2, memo);
    }
}


/**
 * 方法3：动态规划
 *
 * 思路（状态转移方程）：
 *      第n阶爬法的数量=第n-1阶爬法的数量+第n-2阶爬法的数量
 * 
 * 时间复杂度：O(n)
 * 空间复杂度：O(1)
 */
class Solution3 {
    public static int climbStairs(int n) {
        if(n==1 || n==2)return n;
        int xxx =1;
        int xx =2;
        int x = 0;
        int i=3;

        while(i++<=n){
            x=xxx+xx;
            xxx=xx;
            xx=x;
        }
        return x;
    }
}


class aaa {
    public static void main(String[] args) {
        long l = System.currentTimeMillis();
        System.out.println(Solution1.climbStairs(45));
        System.out.println(System.currentTimeMillis()-l);
    }
}

动态规划2：打家劫舍：求可以盗取的最大数（不能盗取相邻元素）

/**
 * 思路（状态转移方程）：
 *      n个元素最大可以盗取数值=
 *          n-2个元素最大可以盗取数值+第n个元素数值
 *          与
 *          n-1个元素最大可以盗取数值
 *          取最大值
 *
 * 时间复杂度：O(n)
 * 空间复杂度：O(1)
 */
class Solution {
    public int rob(int[] nums) {
        if (nums.length == 0) return 0;
        if (nums.length == 1) return nums[0];
        if (nums.length == 2) return nums[0] > nums[1] ? nums[0] : nums[1];

        int xxx = nums[0];  //前前一个最大
        int xx = nums[0] > nums[1] ? nums[0] : nums[1]; //前一个最大
        int x = nums[2];    //当前数
        int sum = 0;

        for (int i = 2; i < nums.length; i++) {
            sum = xx > xxx + x ? xx : xxx + x;
            if (i < nums.length - 1) {
                xxx = xx;
                xx = sum;
                x = nums[i + 1];
            }
        }
        return sum;
    }
}

动态规划3：给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和

/**
 * 思路：
 *  前一个子数组和是正数，则说明有增益，与当前元素相加（前面的子序列对自己有力，保留前面，团结互助）
 *  前一个数组是负数，则说明无增益，子数组从当前数组开始（前面的子序列对自己不利，丢弃前面，自立门户）
 *
 * 状态：dp[i]：表示以 nums[i] 结尾的连续子数组的最大和（如果数组长度为n，则有n种情况）
 * 
 * 状态转移方程：dp[i]=max{nums[i],dp[i−1]+nums[i]}
 * 
 * 时间复杂度：O(N)。
 * 空间复杂度：O(1)。
 */
class Solution {
    public int maxSubArray(int[] nums) {
        int max= nums[0];
        int sum= 0;
        for (int i = 0; i <nums.length ; i++) {
            if(sum<0)sum=nums[i];
            else sum+=nums[i];
            max=Math.max(max,sum);
        }
        return max;
    }
}

动态规划4：最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1

/**
 * 思路：动态规划
 * 
 * 动态转移方程：金额n的最少硬币数=（金额n-各种硬币面值）+1 中所需硬币数最小的元素
 * 
 * 时间复杂度：O(Sn)    S是金额，n是硬币面值数
 * 空间复杂度：O(S)
 */
class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] f = new int[amount + 1];
        f[0] = 0;

        for (int i = 1; i <= amount; i++) {
            int cast = Integer.MAX_VALUE;
            for (int j = 0; j < coins.length; j++) {
                if (i - coins[j] >= 0) {
                    if (f[i - coins[j]] != Integer.MAX_VALUE) cast = Math.min(cast, f[i - coins[j]] + 1);
                }
            }
            f[i] = cast;
        }
        return f[amount] == Integer.MAX_VALUE ? -1 : f[amount];
    }
}

动态规划5：三角形最小路径和（给定一个三角形，找出最小路径和。每一步只能移动到下一行中相邻的结点上）

/**
 * 方法1：记忆化递归法
 * 
 * 思路：
 *      当前元素的最小值=下一层元素两个元素的最小值+当前元素
 */
class Solution2 {
    private Integer[][] arr = null;

    public int minimumTotal(List<List<Integer>> triangle) {
        arr = new Integer[triangle.size()][triangle.size()];
        return helper(0, 0, triangle);
    }

    private int helper(int row, int col, List<List<Integer>> triangle) {
        if (row == triangle.size() - 1) return arr[row][col] = triangle.get(row).get(col);
        if (arr[row][col] != null) return arr[row][col];
        int left = helper(row + 1, col, triangle);
        int right = helper(row + 1, col + 1, triangle);
        return arr[row][col] = Math.min(left, right) + triangle.get(row).get(col);
    }
}


/**
 * 思路（状态转移方程）：自底向上
 *      当前元素的最小值=下一层元素两个元素的最小值+当前元素
 */
class Solution1 {
    public int minimumTotal(List<List<Integer>> triangle) {
        int[] ints = new int[triangle.size() + 1];
        for (int i = triangle.size() - 1; i <= 0; i--) {
            for (int j = 0; j < triangle.get(i).size(); j++) {
                ints[j] = Math.min(ints[j], ints[j + 1]) + triangle.get(i).get(j);
            }
        }
        return ints[0];
    }
}

动态规划6：给定一个无序的整数数组，找到其中最长上升子序列的长度

/**
 * 示例:
 *      输入: [10,9,2,5,3,7,101,18]
 *      输出: 4
 *
 * 思路（状态转移方程）：
 *      dp[i] 表示以 nums[i] 这个数结尾的最长递增子序列的长度。
 *  
 *      设计动态规划算法，需要一个 dp 数组。
 *      我们可以假设 dp[0...i-1]dp[0...i−1] 都已经被算出来了，然后通过这些结果算出 dp[i]的最大值。
 *
 * 时间复杂度 O(N^2)
 * 空间复杂度 O(N)
 */
class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length<2)return nums.length;
        int max=0;
        int[] ints = new int[nums.length];
        ints[0]=1;
        for (int i = 1; i < nums.length; i++) {
            ints[i]=1;
            for (int j = 0; j <i ; j++) {
                if(nums[j]<nums[i]){
                    ints[i]=Math.max(ints[i],ints[j]+1);
                }
            }
            max=Math.max(max,ints[i]);
        }
        return max;
    }
}

动态规划7：给定一个包含非负整数的网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小（只能向下或者向右移动一步）

/**
 * 思路（状态转移方程）：
 *      dp[i][j]=min(dp[i-1][j],dp[i][j-1])+dp[i][j]
 * 
 * 时间复杂度 ：O(mn)。遍历整个矩阵恰好一次。
 * 空间复杂度 ：O(mn)。额外的一个同大小矩阵。
 * 
 * 注：在原数组上存储，这样就不需要额外的存储空间
 */
class Solution {
    public static int minPathSum(int[][] grid) {
        int row = grid.length;
        int col = grid[0].length;

        int[][] ints = new int[row][col];
        ints[0][0] = grid[0][0];

        for (int i = 1; i < row; i++) {
            ints[i][0] = ints[i - 1][0] + grid[i][0];
        }
        for (int i = 1; i < col; i++) {
            ints[0][i] = ints[0][i - 1] + grid[0][i];
        }

        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                ints[i][j] = Math.min(ints[i - 1][j], ints[i][j - 1]) + grid[i][j];
            }
        }
        return ints[row - 1][col - 1];
    }
}