update readme

8 Algorithms Analysis/动态规划.md

@@ -22,6 +22,7 @@ DP通常基于一个递推公式及一个(或多个)初始状态，当前子问
 动态规划的核心思想就是穷举求最值； 动态规划问题的一般形式就是`求最值`,动态规划其实是运筹学的一种最优化方法，只不过在计算机问题上应用比较多，比如说： 
 
 * Fibonacci数列  [代码参考这里 递归](./递归.md)
+* 最大子数组和 
 * 凑零钱问题 
 * 股票问题   [代码参考这里](https://github.com/nonstriater/deep-in-java/blob/master/src/main/java/com/nonstriater/deepinjava/algo/list/stock/BestChance.java)
 * 打家劫舍问题 : num[i] 代表第i个房子中的现金数目，从房子中取钱的最大数目，约束是相邻房子的钱不能同时取出
@@ -29,7 +30,7 @@ DP通常基于一个递推公式及一个(或多个)初始状态，当前子问
 * 青蛙跳阶问题： 一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 10 级的台阶总共有多少种跳法。
 * 最小编辑距离
 * 最长递增子序列 （LIS Longest Increasing Subsequence），如`【5，6，7，3，2，8】` 最长子序列 `【5，6，7，8】`, 输出4
-* 最大子数组和  
+ 
 * 最长公共子序列 （LIS Longest public Subsequence）
 * 最长回文子序列 （LIS Longest public Subsequence）
 * 0-1 背包问题 
@@ -75,7 +76,7 @@ DP 和 回溯法 都会用到递归
 基本步骤
 
 * 划分问题
-* 状态
+* 状态定义， 穷举「状态」， bad case
 * 状态转移方程, 这一步最为困难 ; 暴力解法就是状态转移方程
 * 状态压缩
 
@@ -94,13 +95,96 @@ for 状态1 in 状态1的所有取值：
 
 
 
+## 最大子数组和
+
+示例： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4]，连续子数组 [4,-1,2,1] 的和最大， 输出：6
+
+
+dp[i] 表示 nums[i] 为结尾的「最大子数组和」; dp[n-1] 就是 nums 的「最大子数组和」
+状态转移 : `dp[i] = Math.max(nums[i], nums[i] + dp[i - 1]);`
+状态压缩：注意到 dp[i] 仅仅和 dp[i-1] 的状态有关
+
+
+```Java
+public static int largestSubSequenceSum2(int[] nums){
+
+        int n = nums.length;
+        if (n == 0) return 0;
+
+        // base case
+        int dp_0 = nums[0];
+        int dp_1 = 0;
+        int res = dp_0;
+
+        for (int i = 1; i < n; i++) {
+            // dp[i] = max(nums[i], nums[i] + dp[i-1])
+            dp_1 = Math.max(nums[i], nums[i] + dp_0);
+            dp_0 = dp_1;
+
+            // 顺便计算最大的结果, 保存到 res
+            res = Math.max(res, dp_1);
+        }
+
+        return res;
+
+    }
+```
+
+
 ## 凑零钱问题
 
 凑零钱问题[视频解读参考这里](https://www.ixigua.com/6881883015832666635?wid_try=1)
-[实现代码这里](https://github.com/nonstriater/deep-in-java/tree/master/src/main/java/com/nonstriater/deepinjava/algo/list)
+[实现代码这里](https://github.com/nonstriater/deep-in-java/tree/master/src/main/java/com/nonstriater/deepinjava/algo/framework/dynamic)
 
 如果使用贪心策略，并不能得到最优解。
 
+比如：给定一个面值list ： 1，2，4，5，7，10； 给定一个 target ： 14， 求 凑齐 target=14 , 最少的零钱数量
+
+思路：
+
+如想求 amount = 14 时的最少硬币数，
+  如果你知道凑出 amount = 13 的最少硬币数（子问题）， 再加 1 个 1元面值 即可
+  如果你知道凑出 amount = 12 的最少硬币数（子问题）， 再加 1 个 2元面值 即可
+  如果你知道凑出 amount = 10 的最少硬币数（子问题）， 再加 1 个 4元面值 即可
+  如果你知道凑出 amount = 9 的最少硬币数（子问题）， 再加 1 个 5元面值 即可
+
+
+```Java
+for (int coin : coins) {
+            // 计算子问题的结果
+            int subProblem = dp(coins, amount - coin);
+            // 子问题无解则跳过
+            if (subProblem == -1) continue;
+
+            // 在子问题中选择最优解，然后加一
+            res = Math.min(res, subProblem + 1);
+        }
+```
+
+通过备忘录消除子问题(不用递归了), dp 数组的定义：当目标金额为 i 时，至少需要 dp[i] 枚硬币凑出
+如想求  amount = 14 时的最少硬币数, dp[14]
+    dp[0] = 0
+    dp[1] = 1
+    dp[2] = 1个2元的，dp[1] + 1个1元
+    ...
+    dp[9] = dp[8] + 1个1元， dp[7] + 1个2元， dp[5] + 1个4元， dp[4] + 1个5元，dp[2] + 1个7元   
+    1 + dp[i-coin] 从这些可选项里选择最小的
+
+
+```Java
+//对于 dp[i], 遍历可选项, 选择最小的
+for(int coin : coins) {
+    if (i < coin) {
+        continue;
+    }
+
+    //dp[i] 保留最小的
+    dp[i] = Math.min(dp[i],dp[i-coin] + 1 ) 
+}
+
+```
+
+完整代码如下：
 
 
 ```Java
@@ -134,8 +218,22 @@ for 状态1 in 状态1的所有取值：
 
 ## 股票问题
 
+num[i] 表示第 i 天的股票价格， 设计一个算法(交易策略) ，计算你能获得的最大收益，你最多可以完成 k 笔交易；
+
+比如： [3,2,6,5,1,3]
+k=1  , 第2天买入 2块钱，  第3天卖出 6块，利润 6-2 = 4块 是最大利润
+k= 2 (可以交易2次) ,   [2,6] + [1,3] 是最大利润
+
+动态规划思路如下：
+
+
+* 状态定义：
+* 状态转移：
+* 状态压缩：
+
 
 ```
+
 ```
 
 
@@ -144,6 +242,17 @@ for 状态1 in 状态1的所有取值：
 num[i]表示柱子高度，计算下雨之后最多能接多少雨水 
 
 
+位置i能装多少？
+位置 i 能达到的水柱高度和其左边的最高柱子、右边的最高柱子有关，我们分别称这两个柱子高度为 l_max 和 r_max；位置 i 最大的水柱高度就是 `min(l_max, r_max)`
+
+
+思路：
+
+* 暴力解法
+* 备忘录解法
+* 双指针解法
+
+
 ```
 ```