feat: add solutions to lc problem No.0053. Maximum Subarray

Author: yanglbme

solution/0000-0099/0053.Maximum Subarray/README.md

@@ -64,16 +64,30 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+### 1. 动态规划
+
 设 `dp[i]` 表示 `[0..i]` 中，以 `nums[i]` 结尾的最大子数组和，状态转移方程 `dp[i] = nums[i] + max(dp[i - 1], 0)`。
 
 由于 `dp[i]` 只与子问题 `dp[i-1]` 有关，故可以用一个变量 f 来表示。
 
+### 2. 分治
+
+最大子序和可能有三种情况：
+
+1. 在数组左半部分
+1. 在数组右半部分
+1. 跨越左右半部分
+
+递归求得三者，返回最大值即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+动态规划：
+
 ```python
 class Solution:
     def maxSubArray(self, nums: List[int]) -> int:
@@ -84,10 +98,41 @@ class Solution:
         return res
 ```
 
+分治：
+
+```python
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        def crossMaxSub(nums, left, mid, right):
+            lsum = rsum = 0
+            lmx = rmx = float('-inf')
+            for i in range(mid, left - 1, -1):
+                lsum += nums[i]
+                lmx = max(lmx, lsum)
+            for i in range(mid + 1, right + 1):
+                rsum += nums[i]
+                rmx = max(rmx, rsum)
+            return lmx + rmx
+
+        def maxSub(nums, left, right):
+            if left == right:
+                return nums[left]
+            mid = (left + right) >> 1
+            lsum = maxSub(nums, left, mid)
+            rsum = maxSub(nums, mid + 1, right)
+            csum = crossMaxSub(nums, left, mid, right)
+            return max(lsum, rsum, csum)
+
+        left, right = 0, len(nums) - 1
+        return maxSub(nums, left, right)
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+动态规划：
+
 ```java
 class Solution {
     public int maxSubArray(int[] nums) {
@@ -101,6 +146,40 @@ class Solution {
 }
 ```
 
+分治：
+
+```java
+class Solution {
+    public int maxSubArray(int[] nums) {
+        return maxSub(nums, 0, nums.length - 1);
+    }
+
+    private int maxSub(int[] nums, int left, int right) {
+        if (left == right) {
+            return nums[left];
+        }
+        int mid = (left + right) >>> 1;
+        int lsum = maxSub(nums, left, mid);
+        int rsum = maxSub(nums, mid + 1, right);
+        return Math.max(Math.max(lsum, rsum), crossMaxSub(nums, left, mid, right));
+    }
+
+    private int crossMaxSub(int[] nums, int left, int mid, int right) {
+        int lsum = 0, rsum = 0;
+        int lmx = Integer.MIN_VALUE, rmx = Integer.MIN_VALUE;
+        for (int i = mid; i >= left; --i) {
+            lsum += nums[i];
+            lmx = Math.max(lmx, lsum);
+        }
+        for (int i = mid + 1; i <= right; ++i) {
+            rsum += nums[i];
+            rmx = Math.max(rmx, rsum);
+        }
+        return lmx + rmx;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp

solution/0000-0099/0053.Maximum Subarray/README_EN.md

@@ -42,10 +42,16 @@
 
 ## Solutions
 
+### 1. Dynamic programming
+
+### 2. Divide and Conquer
+
 <!-- tabs:start -->
 
 ### **Python3**
 
+Dynamic programming.
+
 ```python
 class Solution:
     def maxSubArray(self, nums: List[int]) -> int:
@@ -56,8 +62,39 @@ class Solution:
         return res
 ```
 
+Divide and Conquer.
+
+```python
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        def crossMaxSub(nums, left, mid, right):
+            lsum = rsum = 0
+            lmx = rmx = float('-inf')
+            for i in range(mid, left - 1, -1):
+                lsum += nums[i]
+                lmx = max(lmx, lsum)
+            for i in range(mid + 1, right + 1):
+                rsum += nums[i]
+                rmx = max(rmx, rsum)
+            return lmx + rmx
+
+        def maxSub(nums, left, right):
+            if left == right:
+                return nums[left]
+            mid = (left + right) >> 1
+            lsum = maxSub(nums, left, mid)
+            rsum = maxSub(nums, mid + 1, right)
+            csum = crossMaxSub(nums, left, mid, right)
+            return max(lsum, rsum, csum)
+
+        left, right = 0, len(nums) - 1
+        return maxSub(nums, left, right)
+```
+
 ### **Java**
 
+Dynamic programming.
+
 ```java
 class Solution {
     public int maxSubArray(int[] nums) {
@@ -71,6 +108,40 @@ class Solution {
 }
 ```
 
+Divide and Conquer.
+
+```java
+class Solution {
+    public int maxSubArray(int[] nums) {
+        return maxSub(nums, 0, nums.length - 1);
+    }
+
+    private int maxSub(int[] nums, int left, int right) {
+        if (left == right) {
+            return nums[left];
+        }
+        int mid = (left + right) >>> 1;
+        int lsum = maxSub(nums, left, mid);
+        int rsum = maxSub(nums, mid + 1, right);
+        return Math.max(Math.max(lsum, rsum), crossMaxSub(nums, left, mid, right));
+    }
+
+    private int crossMaxSub(int[] nums, int left, int mid, int right) {
+        int lsum = 0, rsum = 0;
+        int lmx = Integer.MIN_VALUE, rmx = Integer.MIN_VALUE;
+        for (int i = mid; i >= left; --i) {
+            lsum += nums[i];
+            lmx = Math.max(lmx, lsum);
+        }
+        for (int i = mid + 1; i <= right; ++i) {
+            rsum += nums[i];
+            rmx = Math.max(rmx, rsum);
+        }
+        return lmx + rmx;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp