新增部分DP算法

Author: jincc

README.md

@@ -5,7 +5,7 @@
 |  1| [两数之和](https://leetcode-cn.com/problems/two-sum/) | [twoSum](./array/leetcode/easy/twoSum.h) | <font color=green>easy</font> | ✅ |
 |  2| [两数相加](https://leetcode-cn.com/problems/add-two-numbers/) | [addTwoNumbers](./linkedList/leetcode/medium/addTwoNumbers.h) | <font color=orange> medium </font> | ✅ |
 |  3| [无重复字符的最长子串](https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/) | [lengthOfLongestSubstring](./string/leetcode/medium/lengthOfLongestSubstring.h) | <font color=orange> medium </font> | ✅ |
-|  5| [最长回文子串](https://leetcode-cn.com/problems/longest-palindromic-substring/) | [longestPalindrome](./string/leetcode/medium/longestPalindrome.h) | <font color=orange> medium </font>[需要回看其他解法] | ✅ |
+|  5| [最长回文子串](https://leetcode-cn.com/problems/longest-palindromic-substring/) | [longestPalindrome](./string/leetcode/medium/longestPalindrome.h) | <font color=orange> medium </font>| ✅ |
 |  6| [Z字形变换](https://leetcode-cn.com/problems/zigzag-conversion/) | [zigzag_conversion](./string/leetcode/medium/zigzag_conversion.h) | <font color=orange> medium </font>| ✅ |
 |  7| [整数反转](https://leetcode-cn.com/problems/reverse-integer/) | [reverse_integer](./other/leetcode/easy/reverse_integer.h) | <font color=green>easy</font> | ✅ |
 |  8| [字符串转换整数 (atoi)](https://leetcode-cn.com/problems/string-to-integer-atoi/) | [string_to_integer_atoi](./string/leetcode/medium/string_to_integer_atoi.h) | <font color=orange> medium </font> | ✅ |
@@ -106,10 +106,10 @@
 回溯算法是”万金油“。基本上贪心和dp能解决的问题，回溯都能解决。回溯相当于穷举搜索，列举出所有的情况，然后对比得到最优解。不过回溯的复杂度一般都是指数级的，只能用来解决小规模数据的问题。-->
 
 
-## [贪心](./greed.md)🚶🚶🚶🚶❌
-## [回溯算法](./backtracking.md)
-## [分治算法](./divideandconquer.md)
-## [动态规划](./dp.md)
+## [贪心](./greed.md)✅
+## [回溯算法](./backtracking.md)✅
+## [分治算法](./divideandconquer.md)🚶🚶🚶🚶
+## [动态规划](./dp.md) ❌
 
 
 ## [字符串匹配](./stringmatch.md)
@@ -127,27 +127,6 @@
 
 ## [数组](./array.md)
 
-数组有两个关键词：
-
-* 线性表结构， 就是说元素之间只有前后关系
-* 连续的内存空间，存储的是具有相同类型的数据
-
-第二个特征决定了数组<font size=5 color=red>“随机访问”</font>的能力，因为我们完全可以通过地址计算出下标对应的位置。比如:
-
-<font size=5>a[i]_add = base_add + i * type_size</font>
-
-有利就有弊，也正是由于内存连续，所以数组的插入和删除是非常低效的，因为为了保持内存的连续，就意味着每次插入/删除都要伴随着<font size=5 color=red>大量的移动操作</font>，平均负责度为o(n).
-
-
-<font size=5 color=red>容器类</font>在数组的基础上，封装了插入删除等操作，同时支持了动态扩容. 需要注意的是，如果实现知道数组的大小，最好提前指定容器大小，这样可以省掉多次的内存申请和数据搬移。
-
-大多情况下的<font size=5 color=red>解题思路</font>:
-
-* 双指针
-* DP
-* 二分查找
-
-
 ## [链表](./linkedList.md) 
 ## [栈&队列](./stack_queue.md)   
 

alg-cpp.xcodeproj/project.pbxproj

@@ -193,6 +193,8 @@
 		09421FFA23142AEB00A7BA67 /* searchRange.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = searchRange.h; sourceTree = "<group>"; };
 		09421FFD231583FC00A7BA67 /* isValidSudoku.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = isValidSudoku.h; sourceTree = "<group>"; };
 		0942542C232942D3006B83E9 /* gas_station.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = gas_station.h; sourceTree = "<group>"; };
+		094524B7234790CD00CCBFB9 /* coinChange.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = coinChange.h; sourceTree = "<group>"; };
+		094524BA234A32D000CCBFB9 /* levenshtein_distance.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = levenshtein_distance.h; sourceTree = "<group>"; };
 		0946B01522F68BA50043469D /* FirstNotRepeatingChar.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FirstNotRepeatingChar.h; sourceTree = "<group>"; };
 		0946B01822F695CE0043469D /* ReverseSentence.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ReverseSentence.h; sourceTree = "<group>"; };
 		0946B01B22F6A5BF0043469D /* StrToInt.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = StrToInt.h; sourceTree = "<group>"; };
@@ -224,6 +226,7 @@
 		0965B3CE23045B1C009A153E /* addBinary.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = addBinary.h; sourceTree = "<group>"; };
 		0965B3D223046663009A153E /* climbStairs.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = climbStairs.h; sourceTree = "<group>"; };
 		0965B3D523046775009A153E /* romanToInt.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = romanToInt.h; sourceTree = "<group>"; };
+		09665E9C234CD7ED003D0FAE /* pascals_triangle.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = pascals_triangle.h; sourceTree = "<group>"; };
 		0969A71B22E607E800CA9347 /* string */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = string; sourceTree = BUILT_PRODUCTS_DIR; };
 		0969A71D22E607E800CA9347 /* main.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = main.cpp; sourceTree = "<group>"; };
 		0969A72222E6081500CA9347 /* matching.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = matching.h; sourceTree = "<group>"; };
@@ -290,6 +293,7 @@
 		09FC39212305A42B00F0A2AE /* addTwoNumbers.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = addTwoNumbers.h; sourceTree = "<group>"; };
 		09FC39252305A9A500F0A2AE /* lengthOfLongestSubstring.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = lengthOfLongestSubstring.h; sourceTree = "<group>"; };
 		09FC39282305B35900F0A2AE /* longestPalindrome.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = longestPalindrome.h; sourceTree = "<group>"; };
+		3A04E7432341F1B7006770AF /* double11advance.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = double11advance.h; sourceTree = "<group>"; };
 		3A091A2C22EFE34800EFA79C /* inorderTraversal.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = inorderTraversal.h; sourceTree = "<group>"; };
 		3A091A2F22EFE62E00EFA79C /* isValidBST.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = isValidBST.h; sourceTree = "<group>"; };
 		3A091A3222F0450400EFA79C /* invertTree.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = invertTree.h; sourceTree = "<group>"; };
@@ -708,6 +712,10 @@
 				3AD40CDC22EAF129002D60A6 /* leetcode */,
 				0998EB8C22E75FB9005A01B5 /* main.cpp */,
 				0998EB9122E75FEC005A01B5 /* knapsack.h */,
+				094524B7234790CD00CCBFB9 /* coinChange.h */,
+				3A04E7432341F1B7006770AF /* double11advance.h */,
+				094524BA234A32D000CCBFB9 /* levenshtein_distance.h */,
+				09665E9C234CD7ED003D0FAE /* pascals_triangle.h */,
 			);
 			path = dp;
 			sourceTree = "<group>";

alg-cpp.xcodeproj/project.xcworkspace/xcuserdata/junl.xcuserdatad/UserInterfaceState.xcuserstate

@@ -22,22 +22,22 @@
 		<key>base.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>7</integer>
+			<integer>5</integer>
 		</dict>
 		<key>bsearch.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>8</integer>
+			<integer>9</integer>
 		</dict>
 		<key>divideandconquer.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>13</integer>
+			<integer>14</integer>
 		</dict>
 		<key>dp.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>10</integer>
+			<integer>12</integer>
 		</dict>
 		<key>greed.xcscheme_^#shared#^_</key>
 		<dict>
@@ -47,12 +47,12 @@
 		<key>hasTable.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>11</integer>
+			<integer>10</integer>
 		</dict>
 		<key>linkedList.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>9</integer>
+			<integer>6</integer>
 		</dict>
 		<key>other.xcscheme_^#shared#^_</key>
 		<dict>
@@ -62,17 +62,17 @@
 		<key>recursion.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>14</integer>
+			<integer>13</integer>
 		</dict>
 		<key>sort.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>5</integer>
+			<integer>8</integer>
 		</dict>
 		<key>stack+queue.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>6</integer>
+			<integer>7</integer>
 		</dict>
 		<key>string.xcscheme_^#shared#^_</key>
 		<dict>
@@ -82,7 +82,7 @@
 		<key>tree.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>12</integer>
+			<integer>11</integer>
 		</dict>
 	</dict>
 	<key>SuppressBuildableAutocreation</key>

alg-cpp.xcodeproj/project.xcworkspace/xcuserdata/junlongj.xcuserdatad/UserInterfaceState.xcuserstate

@@ -1,14 +1,27 @@
-## 分治算法
+# 分治算法
 
-### <font color=red>经典题型</font>
+分治算法的核心思想就是分而治之。将原问题划分成n个规模较小，并且结构与原问题相似的子问题，然后递归的求解这些子问题，再将子问题的解合并成结果，就得到了原问题的解。
+
+
+分治算法能解决的问题，一般要满足下面几个条件:
+
+1. 原问题和分解的小问题具有相同的求解模式.
+2. 分解的子问题可以独立求解，子问题之间没有任何关联，这是分治和动态规划最明显的区别
+3. 具有分解的终止条件，也就是说当问题足够小时，可以直接求解.
+4. 可以将子问题的求解合并成原问题，而这个合并操作的复杂度不能太高，否则就起不到减少算法总体的复杂度恶效果了。
+
+
+
+
+## <font color=red>经典题型</font>
 
 
 | &emsp;题型&emsp; |  答案链接 | 完成度 |
 | :--: | :----------------------------------------------------------- | :--------: |
-|  求一组数据里面的逆序对 | [reversedOrderPairs](./divideConquer/reversedOrderPairs.h)|✅|
-|  二维平面上有n个点，如何快速求出最近的两个点之间的距离  | [closestPair](./divideConquer/closestPair.h)| ❌ |
+|  求一组数据里面的逆序对 | [reversedOrderPairs](./divideandconquer/reversedOrderPairs.h)|✅|
+|  二维平面上有n个点，如何快速求出最近的两个点之间的距离  | [closestPair](./divideandconquer/closestPair.h)| ❌ |
 
-### leetcode
+## leetcode
 | &emsp;题号&emsp; | 题目链接&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;| 答案链接&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;| &emsp;难度&emsp;  | &emsp;完成度&emsp;  |
 | :--: | :--: | :----------------------------------------------------------- | :-----------------------------------------------------------  | :------: |
 |  17   | [电话号码的字母组合](https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/)| --| ✨✨ | ❌ |

alg-cpp.xcodeproj/xcuserdata/junl.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -1,13 +1,29 @@
-## 动态规划
+# 动态规划
+
+
+
+我们把问题的求解分成N个阶段，每个阶段对应一次选择，每次选择之后，会产生不同的状态，我们记录每个阶段的这些状态。然后通过当前的状态集合推导出下一阶段的状态集合，动态的向前推进。
+
+就拿0-1背包问题来说，回溯和动态规划都能解决这个问题。只不过回溯算法解决起来的效率是很低的，时间复杂度是指数级别的，而动态规划在执行效率方面就提高很多，尽管执行效率提高了，但是动态规划的空间复杂度也提高了，所以很多时候我们会说动态规划是一种空间换时间的算法。
+
+
+
+## 什么样的问题适合使用动态规划来解决？
+
+
+动态规划适合用于<font size=5 color=red>多阶段决策最优解模型</font>, 就是说动态规划一般是用来解决最优解问题，而解决问题的过程需要经历多个阶段，每个阶段决策之后会对应一组状态，然后我们寻找一组决策序列，经过这组决策序列，最终求出问题的最优解。
+
+
 
 
 ### <font color=red>经典题型</font>
 
 | &emsp;题型&emsp; |  答案链接 | 完成度 |
 | :--: | :----------------------------------------------------------- | :--------: |
 | 0-1背包问题及变种 | [knapsack](./dp/knapsack.h)|✅|
-|  双11打折优惠问题 | [double11advance](./dp/knapsack.h)|✅|
-|     硬币找零问题  | [coinChange2](./dp/knapsack.h)|✅|
+|  双11打折优惠问题 | [double11advance](./dp/double11advance.h)|✅|
+|     硬币找零问题  | [coinChange2](./dp/coinChange.h)|✅|
+|     杨辉三角变种 | [pascals_triangle](./dp/pascals_triangle.h)|✅|
 |     莱文斯坦最短编辑距离  |  --  |❌|
 | 两个字符串的最长公共子序列 |  --  |❌|
 | 数据序列的最长递增子序列 |  --  | ❌|

divideandconquer.md

@@ -0,0 +1,91 @@
+//
+//  coinChange.h
+//  dp
+//
+//  Created by junl on 2019/10/4.
+//  Copyright © 2019 junl. All rights reserved.
+//
+
+#ifndef coinChange_hpp
+#define coinChange_hpp
+
+#include <stdio.h>
+/*
+ 硬币找零问题。比如我们现在有硬币1元，3元，5元，我们需要支付w元，那么最少需要多少个硬币.
+ 思路：
+    1. 贪心法，每次首先尝试最大面值的币种
+ */
+class coinChange {
+public:
+    //贪心法，首先尝试最大面值的币种
+    void solve(const int coins[], int n, int money, int currentCoinCount){
+        if (money == 0 || currentCoinCount == n) {
+            result = std::min(result, currentCoinCount);
+            return;
+        }
+        for (int i=n-1; i>=0; i--) {
+            if (money >= coins[i]) {
+                solve(coins, n, money - coins[i], currentCoinCount+1);
+            }
+        }
+        
+    }
+    int solve(const int coins[], int n, int money){
+        solve(coins, n, money, 0);
+        return result;
+    }
+private:
+    int result = INT_MAX;
+};
+
+class coinChange_dp {
+public:
+    int solve(const int coins[], int n, int money){
+      //这个找零问题，每次决策后有几个状态变量，第一个是当前的money，第二个是当前使用的硬币数量.所以状态里面至少要包含这两个变量
+        
+        int  max_coin_count = money; //n个1元
+        bool st[max_coin_count][money+1];
+        memset(st, false, sizeof(st));
+        
+        //选择第一个硬币的初始状态
+        for (int i=0; i<n; i++) {
+            if (coins[i] <= money) {
+                st[0][coins[i]] = true;
+            }
+        }
+        
+        for (int index=1; index <= max_coin_count; index++) { //使用第index个硬币的状态
+            for (int last_money = 1; last_money <= money; last_money++) {//计算出使用index个硬币所有可达的状态
+                if (st[index-1][last_money]) { //如果last_money是可达状态，即可以通过硬币筹出来，那么计算下一个阶段的状态
+                    for (int k=n-1; k>=0; k--) {
+                        if (last_money + coins[k] <= money) {
+                            st[index][last_money + coins[k]] = true;
+                        }
+                    }
+                }
+                
+                if (st[index][money]) {
+                    return index+1;
+                }
+            }
+        }
+        return -1;
+        
+    };
+};
+
+
+
+
+
+void test_coinChange(){
+    std::cout << "------------硬币找零问题----------\n" << std::endl;
+    class coinChange so;
+    class coinChange_dp so_dp;
+    int coins[] = {1,3,5};
+    std::cout << so.solve(coins, 3, 9) << std::endl;
+    std::cout << so_dp.solve(coins, 3, 9) << std::endl;
+}
+
+
+#endif /* coinChange_hpp */