Merge pull request apachecn#150 from xshahq/master

第四题增加一个思路和第329题

Author: 0xkookoo

docs/Leetcode_Solutions/C++/004. _Median_of_Two_Sorted_Arrays.md

@@ -1,13 +1,13 @@
 # 004. Median of Two Sorted Arrays
 
-**<font color=red>难度Hard<font>**
+**<font color=red>难度Hard<font>**
 
-## 刷题内容
-> 原题连接
+## 刷题内容
+> 原题连接
 
 * https://leetcode.com/problems/median-of-two-sorted-arrays/submissions/
 
-> 内容描述
+> 内容描述
 
 ```
 There are two sorted arrays nums1 and nums2 of size m and n respectively.
@@ -30,10 +30,10 @@ nums2 = [3, 4]
 The median is (2 + 3)/2 = 2.5
 ```
 
-> 思路1
-******- 时间复杂度: O(n + m)*****- 空间复杂度: O(1)******
+> 思路1
+******- 时间复杂度: O(n + m)******- 空间复杂度: O(1)******
 
-直接用暴利搜索，类似与归并两个有序的数组。遍历两个数组，当总长度等于（m+n）/ 2，注意区分总长度奇数和偶数
+直接用暴利搜索，类似与归并两个有序的数组。遍历两个数组，当总长度等于（m+n）/ 2，注意区分总长度奇数和偶数
 ```cpp
 class Solution {
 public:
@@ -72,10 +72,10 @@ public:
     }
 };
 ```
-> 思路2
-******- 时间复杂度: O(lg(min(n.m)))*****- 空间复杂度: O(1)******
+> 思路2
+******- 时间复杂度: O(lg(min(n.m)))******- 空间复杂度: O(1)******
 
-我们可以通过二分查找优化算法，利用中位数的定义，将两个数组划分为左右两个部分，nums1左半部分加nums2左半部分等于nums1右半部分加nums2的右半部分，如果总长度为偶数，那么nums1左半部分加nums2左半部分等于nums1右半部分加nums2的右半部分加1。并且```max(nums1[i],nums2[j]) <= max(nums1[i + 1],nums2[j + 1])```，接下来我们只要二分查找找i，并且要注意边界情况
+我们可以通过二分查找优化算法，利用中位数的定义，将两个数组划分为左右两个部分，nums1左半部分加nums2左半部分等于nums1右半部分加nums2的右半部分，如果总长度为偶数，那么nums1左半部分加nums2左半部分等于nums1右半部分加nums2的右半部分加1。并且```max(nums1[i],nums2[j]) <= max(nums1[i + 1],nums2[j + 1])```，接下来我们只要二分查找找i，并且要注意边界情况
 
 ```cpp
 class Solution {
@@ -122,4 +122,38 @@ public:
         return sum % 2 ? min1 : (min1 + max1) / 2.0;
     }
 };
-```
+```
+> 思路3
+******- 时间复杂度: O(lg(n+m))******- 空间复杂度: O(1)******
+
+由于题目中建议我们在时间复杂度O(lg(m+n))中完成，我们可以把这题看成寻找第k大的值，这样我们可以递归的去做，每次查找k/2，知道k等于1，注意边界值的处理
+```cpp
+class Solution {
+public:
+int getKth(vector<int> nums1, int start1, int end1, vector<int> nums2, int start2, int end2, int k) {
+        int len1 = end1 - start1 + 1;
+        int len2 = end2 - start2 + 1;
+        if (len1 > len2) return getKth(nums2, start2, end2, nums1, start1, end1, k);
+        if (len1 == 0) return nums2[start2 + k - 1];
+
+        if (k == 1) return min(nums1[start1], nums2[start2]);
+
+        int i = start1 + min(len1, k / 2) - 1;
+        int j = start2 + min(len2, k / 2) - 1;
+
+        if (nums1[i] > nums2[j]) {
+            return getKth(nums1, start1, end1, nums2, j + 1, end2, k - (j - start2 + 1));
+        }
+        else {
+            return getKth(nums1, i + 1, end1, nums2, start2, end2, k - (i - start1 + 1));
+        }
+    }
+double findMedianSortedArrays(vector<int> nums1, vector<int> nums2) {
+    int n = nums1.size();
+    int m = nums2.size();
+    int left = (n + m + 1) / 2;
+    int right = (n + m + 2) / 2;
+    return (getKth(nums1, 0, n - 1, nums2, 0, m - 1, left) + getKth(nums1, 0, n - 1, nums2, 0, m - 1, right)) * 0.5;
+}
+};
+```

docs/Leetcode_Solutions/C++/329._Longest_Increasing_Path_in_a_Matrix.md

@@ -0,0 +1,100 @@
+# 329. Longest Increasing Path in a Matrix
+
+**<font color=red>难度Hard<font>**
+
+## 刷题内容
+> 原题连接
+
+* https://leetcode.com/problems/longest-increasing-path-in-a-matrix/
+
+> 内容描述
+
+```
+Given an integer matrix, find the length of the longest increasing path.
+
+From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).
+
+Example 1:
+
+Input: nums = 
+[
+  [9,9,4],
+  [6,6,8],
+  [2,1,1]
+] 
+Output: 4 
+Explanation: The longest increasing path is [1, 2, 6, 9].
+Example 2:
+
+Input: nums = 
+[
+  [3,4,5],
+  [3,2,6],
+  [2,2,1]
+] 
+Output: 4 
+Explanation: The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.
+```
+
+> 思路
+******- 时间复杂度: O(n * m)******-空间复杂度: O(n * m)******
+
+如果直接用DFS去做，时间复杂度为O(n^4)，我们就需要对算法进行优化，定义一个二维数组用记忆化的方法去记录进行剪枝
+```cpp
+class Solution {
+public:
+    int** dp;
+    int len1,len2,ans;
+    int dfs(vector<vector<int> >&matrix,int i,int j)
+    {
+        if(dp[i][j] != -1)
+            return dp[i][j];
+        //cout << i << j << endl;
+        if(i && matrix[i][j] < matrix[i - 1][j])
+            dp[i][j] = max(dp[i][j],dfs(matrix,i - 1,j) + 1);
+        if(j < len2 - 1 && matrix[i][j] < matrix[i][j + 1])
+            dp[i][j] = max(dp[i][j],dfs(matrix,i,j + 1) + 1);
+        if(i < len1 - 1 && matrix[i][j] < matrix[i + 1][j])
+            dp[i][j] = max(dp[i][j],dfs(matrix,i + 1,j) + 1);
+        if(j && matrix[i][j] < matrix[i][j - 1])
+            dp[i][j] = max(dp[i][j],dfs(matrix,i,j - 1) + 1);
+        //cout << dp[i][j];
+        if(dp[i][j] == -1)
+            dp[i][j] = 1;
+        ans = max(ans,dp[i][j]);
+        return dp[i][j];
+    }
+    int longestIncreasingPath(vector<vector<int>>& matrix) {
+        len1 = matrix.size();
+        if(!len1)
+            return 0;
+        len2 = matrix[0].size();
+        ans = 0;
+        dp = new int*[len1];
+        for(int i = 0; i < len1; ++i){
+            dp[i] = new int[len2];
+            for(int j=0;j<len2;j++)
+                dp[i][j]= -1;
+        }
+        //cout << 1;
+        for(int i = 0;i < matrix.size();++i)
+            for(int j = 0;j < matrix[i].size();++j)
+                if(dp[i][j] == -1)
+                {
+                    //cout << 1;
+                    dfs(matrix,i,j);
+                }
+        reverse(matrix.begin(),matrix.end());
+        for(int i = 0;i < matrix.size();++i)
+            reverse(matrix[i].begin(),matrix[i].end());
+        for(int i = 0;i < len1;++i)
+            for(int j = 0;j < len2;++j)
+                dp[i][j] = -1;
+        for(int i = 0;i < matrix.size();++i)
+            for(int j = 0;j < matrix[i].size();++j)
+                if(dp[i][j] == -1)
+                    dfs(matrix,i,j);
+        return ans;
+    }
+};
+```