leetcode探索动态规划（一）

动态规划基本思想：

若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。 通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量： 一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。 这种做法在重复子问题的数目关于输入的规模呈指数增长时特别有用。

一个问题是该用递推、贪心、搜索还是动态规划，完全是由这个问题本身阶段间状态的转移方式决定的！
 
每个阶段只有一个状态->递推；
每个阶段的最优状态都是由上一个阶段的最优状态得到的->贪心；
每个阶段的最优状态是由之前所有阶段的状态的组合得到的->搜索；
每个阶段的最优状态可以从之前某个阶段的某个或某些状态直接得到而不管之前这个状态是如何得到的->动态规划。

零钱兑换

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

示例 1:

输入: coins = [1, 2, 5], amount = 11

输出: 3
 
解释: 11 = 5 + 5 + 1

示例 2:

输入: coins = [2], amount = 3

输出: -1

代码：

class Solution {
    public int coinChange(int[] coins, int amount) {
       if(coins.length==0 || amount==0){
           return 0;
       }
        Arrays.sort(coins);
        int[] dp = new int[amount+1];
        Arrays.fill(dp,amount+1);//Arrays.fill有两个参数，一个是数组，另一个是要设置的初值，这行代码意思：把dp数组的每个元素初值设置为amount+1
        dp[0] = 0;
        for(int i=1;i<amount+1;i++){
            for(int j=0;j<coins.length&&i>=coins[j];j++){
                dp[i] = Math.min(dp[i],dp[i-coins[j]]+1); //状态转移方程
            }
        }
        return dp[amount]==amount+1?-1:dp[amount];
    }
}

打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。偷窃到的最高金额 = 1 + 3 = 4 。

输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。偷窃到的最高金额 = 2 + 9 + 1 = 12 

代码：

class Solution {
    public int rob(int[] nums) {
        int len = nums.length;
        if(len <=1)
          return len==1?nums[0]:0;
        int[] dp = new int[len];
        dp[0] = nums[0];
        dp[1]= Math.max(nums[1],dp[0]);
        for(int i=2;i<len;i++){
                dp[i] = Math.max(dp[i-1],nums[i]+dp[i-2]);
        }
       return dp[len-1];
    }
}