feat: add solutions to lc problem: No.0053

No.0053.Maximum Subarray

Author: yanglbme

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

@@ -51,42 +51,42 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-### 1. 动态规划
+**方法一：动态规划**
 
-设 `dp[i]` 表示 `[0..i]` 中，以 `nums[i]` 结尾的最大子数组和，状态转移方程 `dp[i] = nums[i] + max(dp[i - 1], 0)`。
+我们定义 $f[i]$ 表示以元素 $nums[i]$ 为结尾的连续子数组的最大和，初始时 $f[0] = nums[0]$，那么最终我们要求的答案即为 $\max_{0 \leq i < n} f[i]$。
 
-由于 `dp[i]` 只与子问题 `dp[i-1]` 有关，故可以用一个变量 f 来表示。
+考虑 $f[i]$，其中 $i \geq 1$，它的状态转移方程为：
 
-### 2. 分治
+$$
+f[i] = \max \{ f[i - 1] + nums[i], nums[i] \}
+$$
 
-最大子数组和可能有三种情况：
+也即：
 
-1. 在数组左半部分
-1. 在数组右半部分
-1. 跨越左右半部分
+$$
+f[i] = \max \{ f[i - 1], 0 \} + nums[i]
+$$
 
-递归求得三者，返回最大值即可。
+由于 $f[i]$ 只与 $f[i - 1]$ 有关系，因此我们可以只用一个变量 $f$ 来维护对于当前 $f[i]$ 的值是多少，然后进行状态转移即可。答案为 $\max_{0 \leq i < n} f$。
+
+时间复杂度 $O(n)$，其中 $n$ 为数组 $nums$ 的长度。我们只需要遍历一遍数组即可求得答案。空间复杂度 $O(1)$，我们只需要常数空间存放若干变量。
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-动态规划：
-
 ```python
 class Solution:
     def maxSubArray(self, nums: List[int]) -> int:
-        res = f = nums[0]
-        for num in nums[1:]:
-            f = num + max(f, 0)
-            res = max(res, f)
-        return res
+        ans = f = nums[0]
+        for x in nums[1:]:
+            f = max(f, 0) + x
+            ans = max(ans, f)
+        return ans
 ```
 
-分治：
-
 ```python
 class Solution:
     def maxSubArray(self, nums: List[int]) -> int:
@@ -118,23 +118,19 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-动态规划：
-
 ```java
 class Solution {
     public int maxSubArray(int[] nums) {
-        int f = nums[0], res = nums[0];
-        for (int i = 1, n = nums.length; i < n; ++i) {
-            f = nums[i] + Math.max(f, 0);
-            res = Math.max(res, f);
+        int ans = nums[0];
+        for (int i = 1, f = nums[0]; i < nums.length; ++i) {
+            f = Math.max(f, 0) + nums[i];
+            ans = Math.max(ans, f);
         }
-        return res;
+        return ans;
     }
 }
 ```
 
-分治：
-
 ```java
 class Solution {
     public int maxSubArray(int[] nums) {
@@ -173,16 +169,49 @@ class Solution {
 class Solution {
 public:
     int maxSubArray(vector<int>& nums) {
-        int f = nums[0], res = nums[0];
+        int ans = nums[0], f = nums[0];
         for (int i = 1; i < nums.size(); ++i) {
-            f = nums[i] + max(f, 0);
-            res = max(res, f);
+            f = max(f, 0) + nums[i];
+            ans = max(ans, f);
         }
-        return res;
+        return ans;
     }
 };
 ```
 
+### **Go**
+
+```go
+func maxSubArray(nums []int) int {
+	ans, f := nums[0], nums[0]
+	for _, x := range nums[1:] {
+		f = max(f, 0) + x
+		ans = max(ans, f)
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
+### **TypeScript**
+
+```ts
+function maxSubArray(nums: number[]): number {
+    let [ans, f] = [nums[0], nums[0]];
+    for (let i = 1; i < nums.length; ++i) {
+        f = Math.max(f, 0) + nums[i];
+        ans = Math.max(ans, f);
+    }
+    return ans;
+}
+```
+
 ### **JavaScript**
 
 ```js
@@ -191,47 +220,26 @@ public:
  * @return {number}
  */
 var maxSubArray = function (nums) {
-    let f = nums[0],
-        res = nums[0];
+    let [ans, f] = [nums[0], nums[0]];
     for (let i = 1; i < nums.length; ++i) {
-        f = nums[i] + Math.max(f, 0);
-        res = Math.max(res, f);
+        f = Math.max(f, 0) + nums[i];
+        ans = Math.max(ans, f);
     }
-    return res;
+    return ans;
 };
 ```
 
-### **Go**
-
-```go
-func maxSubArray(nums []int) int {
-    f, res := nums[0], nums[0]
-    for i := 1; i < len(nums); i++ {
-        if f > 0 {
-            f += nums[i]
-        } else {
-            f = nums[i]
-        }
-        if f > res {
-            res = f
-        }
-    }
-    return res
-}
-```
-
 ### **C#**
 
 ```cs
 public class Solution {
     public int MaxSubArray(int[] nums) {
-        int res = nums[0], f = nums[0];
-        for (int i = 1; i < nums.Length; ++i)
-        {
-            f = nums[i] + Math.Max(f, 0);
-            res = Math.Max(res, f);
+        int ans = nums[0], f = nums[0];
+        for (int i = 1; i < nums.Length; ++i) {
+            f = Math.Max(f, 0) + nums[i];
+            ans = Math.Max(ans, f);
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -242,14 +250,13 @@ public class Solution {
 impl Solution {
     pub fn max_sub_array(nums: Vec<i32>) -> i32 {
         let n = nums.len();
-        let mut res = nums[0];
-        let mut sum = nums[0];
+        let mut ans = nums[0];
+        let mut f = nums[0];
         for i in 1..n {
-            let num = nums[i];
-            sum = num.max(sum + num);
-            res = res.max(sum);
+            f = f.max(0) + nums[i];
+            ans = ans.max(f);
         }
-        res
+        ans
     }
 }
 ```