feat: add solutions to lc problem: No.0410

No.0410.Split Array Largest Sum

Author: yanglbme

solution/0400-0499/0410.Split Array Largest Sum/README.md

@@ -50,9 +50,15 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-二分查找。
+**方法一：二分查找**
 
-二分枚举**子数组的和的最大值**，找到满足条件的最小值。
+我们注意到，当子数组的和的最大值越大，子数组的个数越少，当存在一个满足条件的子数组和的最大值时，那么比这个最大值更大的子数组和的最大值一定也满足条件。也就是说，我们可以对子数组和的最大值进行二分查找，找到满足条件的最小值。
+
+我们定义二分查找的左边界 $left = max(nums)$，右边界 $right = sum(nums)$，然后对于二分查找的每一步，我们取中间值 $mid = (left + right) / 2$，然后判断是否存在一个分割方式，使得子数组的和的最大值不超过 $mid$，如果存在，则说明 $mid$ 可能是满足条件的最小值，因此我们将右边界调整为 $mid$，否则我们将左边界调整为 $mid + 1$。
+
+我们如何判断是否存在一个分割方式，使得子数组的和的最大值不超过 $mid$ 呢？我们可以使用贪心的方法，从左到右遍历数组，将数组中的元素依次加入到子数组中，如果当前子数组的和大于 $mid$，则我们将当前元素加入到下一个子数组中。如果我们能够将数组分割成不超过 $k$ 个子数组，且每个子数组的和的最大值不超过 $mid$，则说明 $mid$ 是满足条件的最小值，否则 $mid$ 不是满足条件的最小值。
+
+时间复杂度 $O(n \times \log m)，空间复杂度 O(1)$。其中 $n$ 和 $m$ 分别是数组的长度和数组所有元素的和。
 
 <!-- tabs:start -->
 
@@ -62,25 +68,18 @@
 
 ```python
 class Solution:
-    def splitArray(self, nums: List[int], m: int) -> int:
-        def check(x):
-            s, cnt = 0, 1
-            for num in nums:
-                if s + num > x:
+    def splitArray(self, nums: List[int], k: int) -> int:
+        def check(mx):
+            s, cnt = inf, 0
+            for x in nums:
+                s += x
+                if s > mx:
+                    s = x
                     cnt += 1
-                    s = num
-                else:
-                    s += num
-            return cnt <= m
+            return cnt <= k
 
         left, right = max(nums), sum(nums)
-        while left < right:
-            mid = (left + right) >> 1
-            if check(mid):
-                right = mid
-            else:
-                left = mid + 1
-        return left
+        return left + bisect_left(range(left, right + 1), True, key=check)
 ```
 
 ### **Java**
@@ -89,15 +88,15 @@ class Solution:
 
 ```java
 class Solution {
-    public int splitArray(int[] nums, int m) {
-        int mx = -1;
-        for (int num : nums) {
-            mx = Math.max(mx, num);
+    public int splitArray(int[] nums, int k) {
+        int left = 0, right = 0;
+        for (int x : nums) {
+            left = Math.max(left, x);
+            right += x;
         }
-        int left = mx, right = (int) 1e9;
         while (left < right) {
             int mid = (left + right) >> 1;
-            if (check(nums, m, mid)) {
+            if (check(nums, mid, k)) {
                 right = mid;
             } else {
                 left = mid + 1;
@@ -106,17 +105,16 @@ class Solution {
         return left;
     }
 
-    private boolean check(int[] nums, int m, int x) {
-        int s = 0, cnt = 1;
-        for (int num : nums) {
-            if (s + num > x) {
+    private boolean check(int[] nums, int mx, int k) {
+        int s = 1 << 30, cnt = 0;
+        for (int x : nums) {
+            s += x;
+            if (s > mx) {
                 ++cnt;
-                s = num;
-            } else {
-                s += num;
+                s = x;
             }
         }
-        return cnt <= m;
+        return cnt <= k;
     }
 }
 ```
@@ -126,29 +124,32 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    int splitArray(vector<int>& nums, int m) {
-        int left = *max_element(nums.begin(), nums.end()), right = (int)1e9;
+    int splitArray(vector<int>& nums, int k) {
+        int left = 0, right = 0;
+        for (int& x : nums) {
+            left = max(left, x);
+            right += x;
+        }
+        auto check = [&](int mx) {
+            int s = 1 << 30, cnt = 0;
+            for (int& x : nums) {
+                s += x;
+                if (s > mx) {
+                    s = x;
+                    ++cnt;
+                }
+            }
+            return cnt <= k;
+        };
         while (left < right) {
-            int mid = left + right >> 1;
-            if (check(nums, m, mid))
+            int mid = (left + right) >> 1;
+            if (check(mid)) {
                 right = mid;
-            else
-                left = mid + 1;
-        }
-        return left;
-    }
-
-    bool check(vector<int>& nums, int m, int x) {
-        int s = 0, cnt = 1;
-        for (int num : nums) {
-            if (s + num > x) {
-                ++cnt;
-                s = num;
             } else {
-                s += num;
+                left = mid + 1;
             }
         }
-        return cnt <= m;
+        return left;
     }
 };
 ```
@@ -157,33 +158,23 @@ public:
 
 ```go
 func splitArray(nums []int, k int) int {
-	mx := -1
-	for _, num := range nums {
-		mx = max(mx, num)
+	left, right := 0, 0
+	for _, x := range nums {
+		left = max(left, x)
+		right += x
 	}
-	left, right := mx, int(1e9)
-	for left < right {
-		mid := (left + right) >> 1
-		if check(nums, k, mid) {
-			right = mid
-		} else {
-			left = mid + 1
+	return left + sort.Search(right-left, func(mx int) bool {
+		mx += left
+		s, cnt := 1<<30, 0
+		for _, x := range nums {
+			s += x
+			if s > mx {
+				s = x
+				cnt++
+			}
 		}
-	}
-	return left
-}
-
-func check(nums []int, k, x int) bool {
-	s, cnt := 0, 1
-	for _, num := range nums {
-		if s+num > x {
-			cnt++
-			s = num
-		} else {
-			s += num
-		}
-	}
-	return cnt <= k
+		return cnt <= k
+	})
 }
 
 func max(a, b int) int {
@@ -194,6 +185,40 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function splitArray(nums: number[], k: number): number {
+    let left = 0;
+    let right = 0;
+    for (const x of nums) {
+        left = Math.max(left, x);
+        right += x;
+    }
+    const check = (mx: number) => {
+        let s = 1 << 30;
+        let cnt = 0;
+        for (const x of nums) {
+            s += x;
+            if (s > mx) {
+                s = x;
+                ++cnt;
+            }
+        }
+        return cnt <= k;
+    };
+    while (left < right) {
+        const mid = (left + right) >> 1;
+        if (check(mid)) {
+            right = mid;
+        } else {
+            left = mid + 1;
+        }
+    }
+    return left;
+}
+```
+
 ### **...**
 
 ```