feat: add solutions to lc problem: No.1838 (#2580)

No.1838.Frequency of the Most Frequent Element

Author: yanglbme

solution/1800-1899/1838.Frequency of the Most Frequent Element/README.md

@@ -1,17 +1,30 @@
-class Solution {
-public:
-    int maxFrequency(vector<int>& nums, int k) {
-        sort(nums.begin(), nums.end());
-        int n = nums.size();
-        int ans = 1;
-        long long window = 0;
-        for (int l = 0, r = 1; r < n; ++r) {
-            window += 1LL * (nums[r] - nums[r - 1]) * (r - l);
-            while (window > k) {
-                window -= (nums[r] - nums[l++]);
-            }
-            ans = max(ans, r - l + 1);
-        }
-        return ans;
-    }
+class Solution {
+public:
+    int maxFrequency(vector<int>& nums, int k) {
+        int n = nums.size();
+        sort(nums.begin(), nums.end());
+        long long s[n + 1];
+        s[0] = 0;
+        for (int i = 1; i <= n; ++i) {
+            s[i] = s[i - 1] + nums[i - 1];
+        }
+        int l = 1, r = n;
+        auto check = [&](int m) {
+            for (int i = m; i <= n; ++i) {
+                if (1LL * nums[i - 1] * m - (s[i] - s[i - m]) <= k) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        while (l < r) {
+            int mid = (l + r + 1) >> 1;
+            if (check(mid)) {
+                l = mid;
+            } else {
+                r = mid - 1;
+            }
+        }
+        return l;
+    }
 };

solution/1800-1899/1838.Frequency of the Most Frequent Element/README_EN.md

@@ -1,13 +1,26 @@
-func maxFrequency(nums []int, k int) int {
-	sort.Ints(nums)
-	ans, window := 1, 0
-	for l, r := 0, 1; r < len(nums); r++ {
-		window += (nums[r] - nums[r-1]) * (r - l)
-		for window > k {
-			window -= nums[r] - nums[l]
-			l++
-		}
-		ans = max(ans, r-l+1)
-	}
-	return ans
+func maxFrequency(nums []int, k int) int {
+	n := len(nums)
+	sort.Ints(nums)
+	s := make([]int, n+1)
+	for i, x := range nums {
+		s[i+1] = s[i] + x
+	}
+	check := func(m int) bool {
+		for i := m; i <= n; i++ {
+			if nums[i-1]*m-(s[i]-s[i-m]) <= k {
+				return true
+			}
+		}
+		return false
+	}
+	l, r := 1, n
+	for l < r {
+		mid := (l + r + 1) >> 1
+		if check(mid) {
+			l = mid
+		} else {
+			r = mid - 1
+		}
+	}
+	return l
 }

solution/1800-1899/1838.Frequency of the Most Frequent Element/Solution.cpp

@@ -1,15 +1,35 @@
-class Solution {
-    public int maxFrequency(int[] nums, int k) {
-        Arrays.sort(nums);
-        int n = nums.length;
-        int ans = 1, window = 0;
-        for (int l = 0, r = 1; r < n; ++r) {
-            window += (nums[r] - nums[r - 1]) * (r - l);
-            while (window > k) {
-                window -= (nums[r] - nums[l++]);
-            }
-            ans = Math.max(ans, r - l + 1);
-        }
-        return ans;
-    }
+class Solution {
+    private int[] nums;
+    private long[] s;
+    private int k;
+
+    public int maxFrequency(int[] nums, int k) {
+        this.k = k;
+        this.nums = nums;
+        Arrays.sort(nums);
+        int n = nums.length;
+        s = new long[n + 1];
+        for (int i = 1; i <= n; ++i) {
+            s[i] = s[i - 1] + nums[i - 1];
+        }
+        int l = 1, r = n;
+        while (l < r) {
+            int mid = (l + r + 1) >> 1;
+            if (check(mid)) {
+                l = mid;
+            } else {
+                r = mid - 1;
+            }
+        }
+        return l;
+    }
+
+    private boolean check(int m) {
+        for (int i = m; i <= nums.length; ++i) {
+            if (1L * nums[i - 1] * m - (s[i] - s[i - m]) <= k) {
+                return true;
+            }
+        }
+        return false;
+    }
 }

solution/1800-1899/1838.Frequency of the Most Frequent Element/Solution.go

@@ -1,13 +1,19 @@
-class Solution:
-    def maxFrequency(self, nums: List[int], k: int) -> int:
-        nums.sort()
-        l, r, n = 0, 1, len(nums)
-        ans, window = 1, 0
-        while r < n:
-            window += (nums[r] - nums[r - 1]) * (r - l)
-            while window > k:
-                window -= nums[r] - nums[l]
-                l += 1
-            r += 1
-            ans = max(ans, r - l)
-        return ans
+class Solution:
+    def maxFrequency(self, nums: List[int], k: int) -> int:
+        def check(m: int) -> bool:
+            for i in range(m, n + 1):
+                if nums[i - 1] * m - (s[i] - s[i - m]) <= k:
+                    return True
+            return False
+
+        n = len(nums)
+        nums.sort()
+        s = list(accumulate(nums, initial=0))
+        l, r = 1, n
+        while l < r:
+            mid = (l + r + 1) >> 1
+            if check(mid):
+                l = mid
+            else:
+                r = mid - 1
+        return l

solution/1800-1899/1838.Frequency of the Most Frequent Element/Solution.java

@@ -1,14 +1,26 @@
 function maxFrequency(nums: number[], k: number): number {
-    nums.sort((a, b) => a - b);
-    let ans = 1;
-    let window = 0;
     const n = nums.length;
-    for (let l = 0, r = 1; r < n; ++r) {
-        window += (nums[r] - nums[r - 1]) * (r - l);
-        while (window > k) {
-            window -= nums[r] - nums[l++];
+    nums.sort((a, b) => a - b);
+    const s: number[] = Array(n + 1).fill(0);
+    for (let i = 1; i <= n; ++i) {
+        s[i] = s[i - 1] + nums[i - 1];
+    }
+    let [l, r] = [1, n];
+    const check = (m: number): boolean => {
+        for (let i = m; i <= n; ++i) {
+            if (nums[i - 1] * m - (s[i] - s[i - m]) <= k) {
+                return true;
+            }
+        }
+        return false;
+    };
+    while (l < r) {
+        const mid = (l + r + 1) >> 1;
+        if (check(mid)) {
+            l = mid;
+        } else {
+            r = mid - 1;
         }
-        ans = Math.max(ans, r - l + 1);
     }
-    return ans;
+    return l;
 }

solution/1800-1899/1838.Frequency of the Most Frequent Element/Solution.js

@@ -1,31 +1,16 @@
-class Solution {
-public:
-    int maxFrequency(vector<int>& nums, int k) {
-        sort(nums.begin(), nums.end());
-        int n = nums.size();
-        long long s[n + 1];
-        s[0] = 0;
-        for (int i = 0; i < n; ++i) {
-            s[i + 1] = s[i] + nums[i];
-        }
-        int left = 1, right = n;
-        auto check = [&](int cnt) {
-            for (int i = 0; i < n + 1 - cnt; ++i) {
-                int j = i + cnt - 1;
-                if (1LL * nums[j] * cnt - (s[j + 1] - s[i]) <= k) {
-                    return true;
-                }
-            }
-            return false;
-        };
-        while (left < right) {
-            int mid = (left + right + 1) >> 1;
-            if (check(mid)) {
-                left = mid;
-            } else {
-                right = mid - 1;
-            }
-        }
-        return left;
-    }
+class Solution {
+public:
+    int maxFrequency(vector<int>& nums, int k) {
+        sort(nums.begin(), nums.end());
+        int ans = 1;
+        long long s = 0;
+        for (int i = 1, j = 0; i < nums.size(); ++i) {
+            s += 1LL * (nums[i] - nums[i - 1]) * (i - j);
+            while (s > k) {
+                s -= nums[i] - nums[j++];
+            }
+            ans = max(ans, i - j + 1);
+        }
+        return ans;
+    }
 };

solution/1800-1899/1838.Frequency of the Most Frequent Element/Solution.py

@@ -1,27 +1,13 @@
-func maxFrequency(nums []int, k int) int {
-	sort.Ints(nums)
-	n := len(nums)
-	s := make([]int, n+1)
-	for i, x := range nums {
-		s[i+1] = s[i] + x
-	}
-	left, right := 1, n
-	check := func(cnt int) bool {
-		for i := 0; i < n+1-cnt; i++ {
-			j := i + cnt - 1
-			if nums[j]*cnt-(s[j+1]-s[i]) <= k {
-				return true
-			}
-		}
-		return false
-	}
-	for left < right {
-		mid := (left + right + 1) >> 1
-		if check(mid) {
-			left = mid
-		} else {
-			right = mid - 1
-		}
-	}
-	return left
+func maxFrequency(nums []int, k int) int {
+	sort.Ints(nums)
+	ans := 1
+	s := 0
+	for i, j := 1, 0; i < len(nums); i++ {
+		s += (nums[i] - nums[i-1]) * (i - j)
+		for ; s > k; j++ {
+			s -= nums[i] - nums[j]
+		}
+		ans = max(ans, i-j+1)
+	}
+	return ans
 }

solution/1800-1899/1838.Frequency of the Most Frequent Element/Solution.ts

@@ -1,37 +1,15 @@
-class Solution {
-    private long[] s;
-    private int[] nums;
-    private int n;
-    private int k;
-
-    public int maxFrequency(int[] nums, int k) {
-        n = nums.length;
-        Arrays.sort(nums);
-        this.nums = nums;
-        this.s = new long[n + 1];
-        for (int i = 0; i < n; ++i) {
-            s[i + 1] = s[i] + nums[i];
-        }
-        this.k = k;
-        int left = 1, right = n;
-        while (left < right) {
-            int mid = (left + right + 1) >>> 1;
-            if (check(mid)) {
-                left = mid;
-            } else {
-                right = mid - 1;
-            }
-        }
-        return left;
-    }
-
-    private boolean check(int cnt) {
-        for (int i = 0; i < n + 1 - cnt; ++i) {
-            int j = i + cnt - 1;
-            if (1L * nums[j] * cnt - (s[j + 1] - s[i]) <= k) {
-                return true;
-            }
-        }
-        return false;
-    }
+class Solution {
+    public int maxFrequency(int[] nums, int k) {
+        Arrays.sort(nums);
+        int ans = 1;
+        long s = 0;
+        for (int i = 1, j = 0; i < nums.length; ++i) {
+            s += 1L * (nums[i] - nums[i - 1]) * (i - j);
+            while (s > k) {
+                s -= nums[i] - nums[j++];
+            }
+            ans = Math.max(ans, i - j + 1);
+        }
+        return ans;
+    }
 }