update readme

2 List/数组.md

@@ -0,0 +1,15 @@
+# 数组
+
+数据与链表差异 [参考这里](README.md)
+
+
+## 循环数组
+
+
+
+
+
+
+
+
+

4 Tree/huffman tree/赫夫曼编码.md

@@ -4,17 +4,21 @@ Huffman在1952年根据香农（Shannon）在1948年和范若（Fano）在1949
 
 这是一个经典的压缩算法。通过`字符出现的频率`，`优先级`，`二叉树` 进行的压缩算法。
 
-对一个字符串，计算每个字符出现的次数,把这些字符放到优先队列（priority queue）
+对一个字符串，计算每个字符出现的次数, 把这些字符放到优先队列（priority queue）； 这个priority queue转出二叉树
-这这个priority queue转出二叉树
 
 需要一个字符编码表来解码,通过二叉树建立huffman编码和解码的字典表
 
 
+
+举一个例子：
+
 原始串：   
 二级制编码：  
 huffman编码：  
 
 
+
+
 ### 存储结构和基本操作
 
 ```

6 Sort/README.md

@@ -145,6 +145,7 @@ void quicksort(int *a, int left, int right){
 
 ```Java
 // pivot 选择 尾部节点， 代码写起来更加简单； 移动元素更方便
+// 左右指针技巧
 static int partition(int[] nums, int left, int right){
 
         int pivot = nums[right];//选尾部节点作为 pivot
@@ -154,11 +155,11 @@ static int partition(int[] nums, int left, int right){
         while (left < right) {
 
             if (nums[left] <= pivot) {
-                left ++ ;
+                left ++ ; //左边指针 窗口变小
                 continue;
             }
 
-            //元素比 pivot 大，右边窗口变小
+            //元素比 pivot 大，右边指针 窗口变小
             //swap left & right
             swap(nums, left, right);
             right--;

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)`
+
+
+思路：
+
+* 暴力解法
+* 备忘录解法
+* 双指针解法
+
+
 ```
 ```
 

9 Algorithms Job Interview/README.md

@@ -153,8 +153,44 @@ public static boolean hasCycle(LinkNode head) {
 
 ### 左右指针
 
-```
 
+快排中 挖坑(pivot) 排序
+```Java
+// pivot 选择 尾部节点， 代码写起来更加简单； 移动元素更方便
+// 左右指针技巧
+static int partition(int[] nums, int left, int right){
+
+        int pivot = nums[right];//选尾部节点作为 pivot
+        int end = right;
+
+        right--;
+        while (left < right) {
+
+            if (nums[left] <= pivot) {
+                left ++ ; //左边指针 窗口变小
+                continue;
+            }
+
+            //元素比 pivot 大，右边指针 窗口变小
+            //swap left & right
+            swap(nums, left, right);
+            right--;
+
+        }
+
+        // 跟 pivot 元素置换
+        int i = 0;
+        if (nums[left] <= pivot) {
+            //swap left+1 & pivot
+           i = left +1;
+        } else {//swap left & pivot
+           i =  left ;
+        }
+
+        swap(nums, i, end);
+
+        return i;
+    }
 ```
 
 
@@ -227,6 +263,10 @@ void mergeSort(int[] nums, int left, int right){
 
 ```
 
+### 动态规划 DP
+
+
+
 
 
 ## [字符串](1%20字符串.md)

README.md

@@ -22,9 +22,9 @@
 * 链表
 * 双向链表
 
-### [数组](2%20List/README.md)
+### [数组](2%20List/数组.md)
 
-* [数组数列问题](%20Algorithms%20Job%20Interview/5%20数组数列问题.md)
+* [数组数列问题](9%20Algorithms%20Job%20Interview/5%20数组数列问题.md)
 
 数组和链表结构是基础结构，散列表、栈、队列、堆、树、图等等各种数据结构都基于数组和链表结构实现。
 
@@ -40,7 +40,7 @@
 
 ### [字符串算法](1%20String/README.md)
 
-* 子串查找 [字符串常见题目参考这里](%20Algorithms%20Job%20Interview/1%20字符串.md) 
+* 子串查找 [字符串常见题目参考这里](9%20Algorithms%20Job%20Interview/1%20字符串.md) 
     * BF算法  
     * KMP算法  
     * BM算法