Merge branch 'master' of https://github.com/azl397985856/leetcode

Author: lucifer

README.md

@@ -193,7 +193,7 @@ leetcode 题解，记录自己的 leetcode 解题之路。
 - [0139.word-break](./problems/139.word-break.md)
 - [0144.binary-tree-preorder-traversal](./problems/144.binary-tree-preorder-traversal.md)
 - [0150.evaluate-reverse-polish-notation](./problems/150.evaluate-reverse-polish-notation.md)
-- [0152.maximum-product-subarray](./problems/152.maximum-product-subarray.md)
+- [0152.maximum-product-subarray](./problems/152.maximum-product-subarray.md) 🖊
 - [0199.binary-tree-right-side-view](./problems/199.binary-tree-right-side-view.md)
 - [0200.number-of-islands](./problems/200.number-of-islands.md) 🆕
 - [0201.bitwise-and-of-numbers-range](./problems/201.bitwise-and-of-numbers-range.md) 🖊

daily/2019-08-09.md

@@ -20,26 +20,28 @@
 解释: 因为路径 1→3→1→1→1 的总和最小。
 ```
 ## 参考答案
-动态规划求解，时间复杂度O(n*m)
->
-我们新建一个额外的dp数组，与原矩阵大小相同。在这个矩阵中,dp(i,j)表示从坐标(i,j)到右下角的最小路径权值。我们初始化右下角的dp值为对应的原矩阵值，然后去填整个矩阵，对于每个元素考虑移动到右边或者下面，因此获得最小路径和我们有如下递推公式：`dp(i,j)=grid(i,j)+min(dp(i+1,j),dp(i,j+1))`
+
+我们新建一个额外的dp数组，与原矩阵大小相同。在这个矩阵中,dp(i,j)表示从原点到坐标(i,j)的最小路径和。我们初始化dp值为对应的原矩阵值，然后去填整个矩阵，对于每个元素考虑从上方移动过来还是从左方移动过来，因此获得最小路径和我们有如下递推公式：`dp(i,j)=grid(i,j)+min(dp(i-1,j),dp(i,j-1))`
+
+
+我们可以使用原地算法，这样就不需要开辟dp数组，空间复杂度可以降低到$O(1)$。
+
 ```c++
 class Solution {
 public:
     int minPathSum(vector<vector<int>>& grid) {
-        //剪枝
         int n = grid.size();
         if(n==0)
             return 0;
         int m = grid[0].size();
         if(m==0)
             return 0;
-        //初始化第一列
+        //初始化第一行
         for(int i=1;i<m;i++)
         {
             grid[0][i] += grid[0][i-1];
         }
-        //初始化第一排
+        //初始化第一列
         for(int i=1;i<n;i++)
         {
             grid[i][0] += grid[i-1][0];
@@ -57,6 +59,11 @@ public:
     }
 };
 ```
+
+
+**复杂度分析**
+- 时间复杂度：$O(M * N)$
+- 空间复杂度：$O(1)$
 ## 其他优秀解答
 
-> 暂缺
+> 暂缺

problems/152.maximum-product-subarray.md

@@ -49,52 +49,75 @@ var maxProduct = function(nums) {
 
 因此我们需要同时记录乘积最大值和乘积最小值，然后比较元素和这两个的乘积，去不断更新最大值。
 
-![152.maximum-product-subarray](../assets/problems/152.maximum-product-subarray.png)
+![](https://tva1.sinaimg.cn/large/0082zybply1gcatuvun39j30gr08kt9l.jpg)
 
 这种思路的解法由于只需要遍历一次，其时间复杂度是O(n)，代码见下方代码区。
+
 ## 关键点
 
 - 同时记录乘积最大值和乘积最小值
-
 ## 代码
 
+代码支持：Python3，JavaScript
+
+
+
+Python3 Code:
+
+
+```python
+
+
+class Solution:
+    def maxProduct(self, nums: List[int]) -> int:
+        n = len(nums)
+        max__dp = [1] * (n + 1)
+        min_dp = [1] * (n + 1)
+        ans = float('-inf')
+
+        for i in range(1, n + 1):
+            max__dp[i] = max(max__dp[i - 1] * nums[i - 1],
+                             min_dp[i - 1] * nums[i - 1], nums[i - 1])
+            min_dp[i] = min(max__dp[i - 1] * nums[i - 1],
+                            min_dp[i - 1] * nums[i - 1], nums[i - 1])
+            ans = max(ans, max__dp[i])
+        return ans
+  ```
+
+
+**复杂度分析**
+- 时间复杂度：$O(N)$
+- 空间复杂度：$O(N)$
+
+
+当我们知道动态转移方程的时候，其实应该发现了。我们的dp[i] 只和 dp[i - 1]有关，这是一个空间优化的信号，告诉我们`可以借助两个额外变量记录即可`。
+
+
+Python3 Code:
+
+
+```python
+
+class Solution:
+    def maxProduct(self, nums: List[int]) -> int:
+        n = len(nums)
+        a = b = 1
+        ans = float('-inf')
+
+        for i in range(1, n + 1):
+            temp = a
+            a = max(a * nums[i - 1],
+                    b * nums[i - 1], nums[i - 1])
+            b = min(temp * nums[i - 1],
+                    b * nums[i - 1], nums[i - 1])
+            ans = max(ans, a)
+        return ans
+
+```
+
+JavaScript Code:
+
 ```js
-/*
- * @lc app=leetcode id=152 lang=javascript
- *
- * [152] Maximum Product Subarray
- *
- * https://leetcode.com/problems/maximum-product-subarray/description/
- *
- * algorithms
- * Medium (28.61%)
- * Total Accepted:    202.8K
- * Total Submissions: 700K
- * Testcase Example:  '[2,3,-2,4]'
- *
- * Given an integer array nums, find the contiguous subarray within an array
- * (containing at least one number) which has the largest product.
- *
- * Example 1:
- *
- *
- * Input: [2,3,-2,4]
- * Output: 6
- * Explanation: [2,3] has the largest product 6.
- *
- *
- * Example 2:
- *
- *
- * Input: [-2,0,-1]
- * Output: 0
- * Explanation: The result cannot be 2, because [-2,-1] is not a subarray.
- *
- */
-/**
- * @param {number[]} nums
- * @return {number}
- */
 var maxProduct = function(nums) {
   let max = nums[0];
   let min = nums[0];
@@ -109,3 +132,8 @@ var maxProduct = function(nums) {
   return res;
 };
 ```
+
+
+**复杂度分析**
+- 时间复杂度：$O(N)$
+- 空间复杂度：$O(1)$

problems/206.reverse-linked-list.md

@@ -25,39 +25,11 @@ A linked list can be reversed either iteratively or recursively. Could you imple
 
 ## 代码
 
-语言支持：JS, C++, Python
+语言支持：JS, C++, Python,Java
 
 JavaScript Code：
 
 ```js
-/*
- * @lc app=leetcode id=206 lang=javascript
- *
- * [206] Reverse Linked List
- *
- * https://leetcode.com/problems/reverse-linked-list/description/
- *
- * algorithms
- * Easy (52.95%)
- * Total Accepted:    532.6K
- * Total Submissions: 1M
- * Testcase Example:  '[1,2,3,4,5]'
- *
- * Reverse a singly linked list.
- *
- * Example:
- *
- *
- * Input: 1->2->3->4->5->NULL
- * Output: 5->4->3->2->1->NULL
- *
- *
- * Follow up:
- *
- * A linked list can be reversed either iteratively or recursively. Could you
- * implement both?
- *
- */
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {
@@ -134,6 +106,33 @@ class Solution:
         return prev
 ```
 
+Java Code:
+
+```java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode reverseList(ListNode head) {
+        ListNode pre = null, cur = head;
+
+        while (cur != null) {
+            ListNode next = cur.next;
+            cur.next = pre;
+            pre = cur;
+            cur = next;
+        }
+
+        return pre;
+    }
+}
+```
+
 ## 拓展
 
 通过单链表的定义可以得知，单链表也是递归结构，因此，也可以使用递归的方式来进行reverse操作。

problems/322.coin-change.md

@@ -55,6 +55,37 @@ eg: 对于 [1,2,5] 组成 11 块
 
 对于动态规划我们可以先画一个二维表，然后观察，其是否可以用一维表代替。
 关于动态规划为什么要画表，我已经在[这篇文章](../thinkings/dynamic-programming.md)解释了
+
+比较容易想到的是二维数组：
+
+```python
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        if amount < 0:
+            return - 1
+        dp = [[amount + 1 for _ in range(len(coins) + 1)]
+              for _ in range(amount + 1)]
+        # 初始化第一行为0，其他为最大值（也就是amount + 1）
+
+        for j in range(len(coins) + 1):
+            dp[0][j] = 0
+
+        for i in range(1, amount + 1):
+            for j in range(1, len(coins) + 1):
+                if i - coins[j - 1] >= 0:
+                    dp[i][j] = min(
+                        dp[i][j - 1], dp[i - coins[j - 1]][j] + 1)
+                else:
+                    dp[i][j] = dp[i][j - 1]
+
+        return -1 if dp[-1][-1] == amount + 1 else dp[-1][-1]
+ ```
+ 
+ **复杂度分析**
+- 时间复杂度：$O(amonut * len(coins))$
+- 空间复杂度：$O(amount * len(coins))$
+
+dp[i][j] 依赖于` dp[i][j - 1]`和 `dp[i - coins[j - 1]][j] + 1)` 这是一个优化的信号，我们可以将其优化到一维,具体见下方。
 ## 关键点解析
 
 - 动态规划
@@ -73,51 +104,11 @@ eg: 对于 [1,2,5] 组成 11 块
 
 ## 代码
 
-* 语言支持：JS，C++
+
+* 语言支持：JS，C++,Python3
 
 JavaScript Code：
 ```js
-/*
- * @lc app=leetcode id=322 lang=javascript
- *
- * [322] Coin Change
- *
- * https://leetcode.com/problems/coin-change/description/
- *
- * algorithms
- * Medium (29.25%)
- * Total Accepted:    175K
- * Total Submissions: 591.9K
- * Testcase Example:  '[1,2,5]\n11'
- *
- * You are given coins of different denominations and a total amount of money
- * amount. Write a function to compute the fewest number of coins that you need
- * to make up that amount. If that amount of money cannot be made up by any
- * combination of the coins, return -1.
- *
- * Example 1:
- *
- *
- * Input: coins = [1, 2, 5], amount = 11
- * Output: 3
- * Explanation: 11 = 5 + 5 + 1
- *
- * Example 2:
- *
- *
- * Input: coins = [2], amount = 3
- * Output: -1
- *
- *
- * Note:
- * You may assume that you have an infinite number of each kind of coin.
- *
- */
-/**
- * @param {number[]} coins
- * @param {number} amount
- * @return {number}
- */
 
 var coinChange = function(coins, amount) {
     if (amount === 0) {
@@ -157,10 +148,32 @@ public:
     }
 };
 ```
+
+Python3 Code:
+
+```python
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        dp = [amount + 1] * (amount + 1)
+        dp[0] = 0
+
+        for i in range(1, amount + 1):
+            for j in range(len(coins)):
+                if i >= coins[j]:
+                    dp[i] = min(dp[i], dp[i - coins[j]] + 1)
+
+        return -1 if dp[-1] == amount + 1 else dp[-1]
+```
+
+**复杂度分析**
+- 时间复杂度：$O(amonut * len(coins))$
+- 空间复杂度：$O(amount)$
+
+
 ## 扩展
 
 这是一道很简单描述的题目， 因此很多时候会被用到大公司的电面中。
 
 相似问题:
 
-[518.coin-change-2](./518.coin-change-2.md)
+[518.coin-change-2](https://github.com/azl397985856/leetcode/blob/master/problems/518.coin-change-2.md)