feat: update solutions to lc problem: No.0813

No.0813.Largest Sum of Averages

Author: yanglbme

solution/0800-0899/0813.Largest Sum of Averages/README.md

@@ -48,19 +48,17 @@ nums 的最优分组是[9], [1, 2, 3], [9]. 得到的分数是 9 + (1 + 2 + 3) /
 
 **方法一：记忆化搜索**
 
-定义 $n$ 表示数组 `nums` 的长度。
-
-我们设计函数 $dfs(i, k)$，表示从数组下标 $i$ 开始，最多分成 $k$ 组的最大平均值和。答案为 $dfs(0, k)$。
+我们设计一个函数 $dfs(i, k)$，表示从数组下标 $i$ 开始，最多分成 $k$ 组的最大平均值和。答案为 $dfs(0, k)$。函数 $dfs(i, k)$ 的执行逻辑如下：
 
 当 $i=n$ 时，表示已经遍历到数组末尾，此时返回 $0$。
 
 当 $k=1$ 时，表示只剩下一组，此时返回从下标 $i$ 开始到数组末尾的平均值。
 
-否则，我们在 $[i, ..n-1]$ 的范围内枚举分组的结束位置 $j$，计算从下标 $i$ 到下标 $j$ 的平均值，以及从下标 $j+1$ 开始，最多分成 $k-1$ 组的最大平均值和，取二者之和的最大值。
+否则，我们在 $[i, ..n-1]$ 的范围内枚举分组的结束位置 $j$，计算从下标 $i$ 到下标 $j$ 的平均值，以及从下标 $j+1$ 开始，最多分成 $k-1$ 组的最大平均值和。取其中的最大值作为答案。
 
-为了避免重复计算，我们用数组 $f$ 记忆化函数 $dfs(i, k)$ 的返回值。
+为了避免重复计算，我们可以用数组 $f$ 记忆化函数 $dfs(i, k)$ 的返回值。
 
-时间复杂度 $O(n^2\times k)$。其中 $n$ 表示数组 `nums` 的长度。
+时间复杂度 $O(n^2 \times k)$，空间复杂度 $O(n \times k)$。其中 $n$ 表示数组 `nums` 的长度。
 
 <!-- tabs:start -->
 
@@ -94,17 +92,14 @@ class Solution:
 
 ```java
 class Solution {
-    private double[][] f;
+    private Double[][] f;
     private int[] s;
     private int n;
 
     public double largestSumOfAverages(int[] nums, int k) {
         n = nums.length;
         s = new int[n + 1];
-        f = new double[n + 1][k + 1];
-        for (var e : f) {
-            Arrays.fill(e, -1);
-        }
+        f = new Double[n + 1][k + 1];
         for (int i = 0; i < n; ++i) {
             s[i + 1] = s[i] + nums[i];
         }
@@ -118,16 +113,15 @@ class Solution {
         if (k == 1) {
             return (s[n] - s[i]) * 1.0 / (n - i);
         }
-        if (f[i][k] >= 0) {
+        if (f[i][k] != null) {
             return f[i][k];
         }
         double ans = 0;
         for (int j = i; j < n; ++j) {
             double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
             ans = Math.max(ans, t);
         }
-        f[i][k] = ans;
-        return ans;
+        return f[i][k] = ans;
     }
 }
 ```
@@ -137,38 +131,26 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    double f[110][110];
-    int s[110];
-    int n;
-
     double largestSumOfAverages(vector<int>& nums, int k) {
-        n = nums.size();
+        int n = nums.size();
+        int s[n + 1];
+        double f[n][k + 1];
         s[0] = 0;
-        for (int i = 0; i < n; ++i) {
-            s[i + 1] = s[i] + nums[i];
-        }
-        memset(f, -1, sizeof f);
+        memset(f, 0, sizeof f);
+        for (int i = 0; i < n; ++i) s[i + 1] = s[i] + nums[i];
+        function<double(int, int)> dfs = [&](int i, int k) -> double {
+            if (i == n) return 0;
+            if (k == 1) return (s[n] - s[i]) * 1.0 / (n - i);
+            if (f[i][k]) return f[i][k];
+            double ans = 0;
+            for (int j = i; j < n; ++j) {
+                double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
+                ans = max(ans, t);
+            }
+            return f[i][k] = ans;
+        };
         return dfs(0, k);
     }
-
-    double dfs(int i, int k) {
-        if (i == n) {
-            return 0;
-        }
-        if (k == 1) {
-            return (s[n] - s[i]) * 1.0 / (n - i);
-        }
-        if (f[i][k] >= 0) {
-            return f[i][k];
-        }
-        double ans = 0;
-        for (int j = i; j < n; ++j) {
-            double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
-            ans = max(ans, t);
-        }
-        f[i][k] = ans;
-        return ans;
-    }
 };
 ```
 
@@ -178,13 +160,7 @@ public:
 func largestSumOfAverages(nums []int, k int) float64 {
 	n := len(nums)
 	s := make([]int, n+1)
-	f := make([][]float64, n+1)
-	for i := range f {
-		f[i] = make([]float64, k+1)
-		for j := range f[i] {
-			f[i][j] = -1
-		}
-	}
+	f := [110][110]float64{}
 	for i, v := range nums {
 		s[i+1] = s[i] + v
 	}
@@ -196,7 +172,7 @@ func largestSumOfAverages(nums []int, k int) float64 {
 		if k == 1 {
 			return float64(s[n]-s[i]) / float64(n-i)
 		}
-		if f[i][k] >= 0 {
+		if f[i][k] > 0 {
 			return f[i][k]
 		}
 		var ans float64

solution/0800-0899/0813.Largest Sum of Averages/README_EN.md

@@ -68,17 +68,14 @@ class Solution:
 
 ```java
 class Solution {
-    private double[][] f;
+    private Double[][] f;
     private int[] s;
     private int n;
 
     public double largestSumOfAverages(int[] nums, int k) {
         n = nums.length;
         s = new int[n + 1];
-        f = new double[n + 1][k + 1];
-        for (var e : f) {
-            Arrays.fill(e, -1);
-        }
+        f = new Double[n + 1][k + 1];
         for (int i = 0; i < n; ++i) {
             s[i + 1] = s[i] + nums[i];
         }
@@ -92,16 +89,15 @@ class Solution {
         if (k == 1) {
             return (s[n] - s[i]) * 1.0 / (n - i);
         }
-        if (f[i][k] >= 0) {
+        if (f[i][k] != null) {
             return f[i][k];
         }
         double ans = 0;
         for (int j = i; j < n; ++j) {
             double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
             ans = Math.max(ans, t);
         }
-        f[i][k] = ans;
-        return ans;
+        return f[i][k] = ans;
     }
 }
 ```
@@ -111,38 +107,26 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    double f[110][110];
-    int s[110];
-    int n;
-
     double largestSumOfAverages(vector<int>& nums, int k) {
-        n = nums.size();
+        int n = nums.size();
+        int s[n + 1];
+        double f[n][k + 1];
         s[0] = 0;
-        for (int i = 0; i < n; ++i) {
-            s[i + 1] = s[i] + nums[i];
-        }
-        memset(f, -1, sizeof f);
+        memset(f, 0, sizeof f);
+        for (int i = 0; i < n; ++i) s[i + 1] = s[i] + nums[i];
+        function<double(int, int)> dfs = [&](int i, int k) -> double {
+            if (i == n) return 0;
+            if (k == 1) return (s[n] - s[i]) * 1.0 / (n - i);
+            if (f[i][k]) return f[i][k];
+            double ans = 0;
+            for (int j = i; j < n; ++j) {
+                double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
+                ans = max(ans, t);
+            }
+            return f[i][k] = ans;
+        };
         return dfs(0, k);
     }
-
-    double dfs(int i, int k) {
-        if (i == n) {
-            return 0;
-        }
-        if (k == 1) {
-            return (s[n] - s[i]) * 1.0 / (n - i);
-        }
-        if (f[i][k] >= 0) {
-            return f[i][k];
-        }
-        double ans = 0;
-        for (int j = i; j < n; ++j) {
-            double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
-            ans = max(ans, t);
-        }
-        f[i][k] = ans;
-        return ans;
-    }
 };
 ```
 
@@ -152,13 +136,7 @@ public:
 func largestSumOfAverages(nums []int, k int) float64 {
 	n := len(nums)
 	s := make([]int, n+1)
-	f := make([][]float64, n+1)
-	for i := range f {
-		f[i] = make([]float64, k+1)
-		for j := range f[i] {
-			f[i][j] = -1
-		}
-	}
+	f := [110][110]float64{}
 	for i, v := range nums {
 		s[i+1] = s[i] + v
 	}
@@ -170,7 +148,7 @@ func largestSumOfAverages(nums []int, k int) float64 {
 		if k == 1 {
 			return float64(s[n]-s[i]) / float64(n-i)
 		}
-		if f[i][k] >= 0 {
+		if f[i][k] > 0 {
 			return f[i][k]
 		}
 		var ans float64

solution/0800-0899/0813.Largest Sum of Averages/Solution.cpp

@@ -1,35 +1,23 @@
 class Solution {
 public:
-    double f[110][110];
-    int s[110];
-    int n;
-
     double largestSumOfAverages(vector<int>& nums, int k) {
-        n = nums.size();
+        int n = nums.size();
+        int s[n + 1];
+        double f[n][k + 1];
         s[0] = 0;
-        for (int i = 0; i < n; ++i) {
-            s[i + 1] = s[i] + nums[i];
-        }
-        memset(f, -1, sizeof f);
+        memset(f, 0, sizeof f);
+        for (int i = 0; i < n; ++i) s[i + 1] = s[i] + nums[i];
+        function<double(int, int)> dfs = [&](int i, int k) -> double {
+            if (i == n) return 0;
+            if (k == 1) return (s[n] - s[i]) * 1.0 / (n - i);
+            if (f[i][k]) return f[i][k];
+            double ans = 0;
+            for (int j = i; j < n; ++j) {
+                double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
+                ans = max(ans, t);
+            }
+            return f[i][k] = ans;
+        };
         return dfs(0, k);
     }
-
-    double dfs(int i, int k) {
-        if (i == n) {
-            return 0;
-        }
-        if (k == 1) {
-            return (s[n] - s[i]) * 1.0 / (n - i);
-        }
-        if (f[i][k] >= 0) {
-            return f[i][k];
-        }
-        double ans = 0;
-        for (int j = i; j < n; ++j) {
-            double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
-            ans = max(ans, t); 
-        }
-        f[i][k] = ans;
-        return ans;
-    }
 };

solution/0800-0899/0813.Largest Sum of Averages/Solution.go

@@ -1,13 +1,7 @@
 func largestSumOfAverages(nums []int, k int) float64 {
 	n := len(nums)
 	s := make([]int, n+1)
-	f := make([][]float64, n+1)
-	for i := range f {
-		f[i] = make([]float64, k+1)
-		for j := range f[i] {
-			f[i][j] = -1
-		}
-	}
+	f := [110][110]float64{}
 	for i, v := range nums {
 		s[i+1] = s[i] + v
 	}
@@ -19,7 +13,7 @@ func largestSumOfAverages(nums []int, k int) float64 {
 		if k == 1 {
 			return float64(s[n]-s[i]) / float64(n-i)
 		}
-		if f[i][k] >= 0 {
+		if f[i][k] > 0 {
 			return f[i][k]
 		}
 		var ans float64

solution/0800-0899/0813.Largest Sum of Averages/Solution.java

@@ -1,15 +1,12 @@
 class Solution {
-    private double[][] f;
+    private Double[][] f;
     private int[] s;
     private int n;
 
     public double largestSumOfAverages(int[] nums, int k) {
         n = nums.length;
         s = new int[n + 1];
-        f = new double[n + 1][k + 1];
-        for (var e : f) {
-            Arrays.fill(e, -1);
-        }
+        f = new Double[n + 1][k + 1];
         for (int i = 0; i < n; ++i) {
             s[i + 1] = s[i] + nums[i];
         }
@@ -23,15 +20,14 @@ private double dfs(int i, int k) {
         if (k == 1) {
             return (s[n] - s[i]) * 1.0 / (n - i);
         }
-        if (f[i][k] >= 0) {
+        if (f[i][k] != null) {
             return f[i][k];
         }
         double ans = 0;
         for (int j = i; j < n; ++j) {
             double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
             ans = Math.max(ans, t);
         }
-        f[i][k] = ans;
-        return ans;
+        return f[i][k] = ans;
     }
 }

solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README.md

@@ -72,7 +72,7 @@
 ```python
 class Solution:
     def check(self, nums: List[int]) -> bool:
-        return sum(v > nums[(i + 1) % len(nums)] for i, v in enumerate(nums)) <= 1
+        return sum(nums[i - 1] > v for i, v in enumerate(nums)) <= 1
 ```
 
 ### **Java**

solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README_EN.md

@@ -54,7 +54,7 @@ You can rotate the array by x = 0 positions (i.e. no rotation) to make nums.
 ```python
 class Solution:
     def check(self, nums: List[int]) -> bool:
-        return sum(v > nums[(i + 1) % len(nums)] for i, v in enumerate(nums)) <= 1
+        return sum(nums[i - 1] > v for i, v in enumerate(nums)) <= 1
 ```
 
 ### **Java**

solution/1700-1799/1752.Check if Array Is Sorted and Rotated/Solution.py

@@ -1,3 +1,3 @@
 class Solution:
     def check(self, nums: List[int]) -> bool:
-        return sum(v > nums[(i + 1) % len(nums)] for i, v in enumerate(nums)) <= 1
+        return sum(nums[i - 1] > v for i, v in enumerate(nums)) <= 1