feat: add solutions to lc problem: No.1891

No.1891.Cutting Ribbons

Author: yanglbme

solution/1100-1199/1137.N-th Tribonacci Number/README_EN.md

@@ -43,11 +43,8 @@ T_4 = 1 + 1 + 2 = 4
 <p><strong>Constraints:</strong></p>
 
 <ul>
-
     <li><code>0 &lt;= n &lt;= 37</code></li>
-
     <li>The answer is guaranteed to fit within a 32-bit integer, ie. <code>answer &lt;= 2^31 - 1</code>.</li>
-
 </ul>
 
 ## Solutions

solution/1800-1899/1891.Cutting Ribbons/README.md

@@ -66,7 +66,15 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-“二分法”实现。
+**方法一：二分查找**
+
+我们发现，如果我们能够得到长度为 $x$ 的 $k$ 根绳子，那么我们一定能够得到长度为 $x - 1$ 的 $k$ 根绳子，这存在着单调性。因此，我们可以使用二分查找的方法，找到最大的长度 $x$，使得我们能够得到长度为 $x$ 的 $k$ 根绳子。
+
+我们定义二分查找的左边界 $left=0$, $right=10^5$，中间值 $mid=(left+right+1)/2$，然后计算当前长度为 $mid$ 的绳子能够得到的数量 $cnt$，如果 $cnt \geq k$，说明我们能够得到长度为 $mid$ 的 $k$ 根绳子，那么我们将 $left$ 更新为 $mid$，否则我们将 $right$ 更新为 $mid-1$。
+
+最后，我们返回 $left$ 即可。
+
+时间复杂度 $O(n \times \log M)$，空间复杂度 $O(1)$。其中 $n$ 和 $M$ 分别为绳子的数量和绳子的最大长度。
 
 <!-- tabs:start -->
 
@@ -77,17 +85,15 @@
 ```python
 class Solution:
     def maxLength(self, ribbons: List[int], k: int) -> int:
-        low, high = 0, 100000
-        while low < high:
-            mid = (low + high + 1) >> 1
-            cnt = 0
-            for ribbon in ribbons:
-                cnt += ribbon // mid
-            if cnt < k:
-                high = mid - 1
+        left, right = 0, 100000
+        while left < right:
+            mid = (left + right + 1) >> 1
+            cnt = sum(x // mid for x in ribbons)
+            if cnt >= k:
+                left = mid
             else:
-                low = mid
-        return low
+                right = mid - 1
+        return left
 ```
 
 ### **Java**
@@ -97,71 +103,44 @@ class Solution:
 ```java
 class Solution {
     public int maxLength(int[] ribbons, int k) {
-        int low = 0, high = 100000;
-        while (low < high) {
-            int mid = (low + high + 1) >> 1;
+        int left = 0, right = 100000;
+        while (left < right) {
+            int mid = (left + right + 1) >>> 1;
             int cnt = 0;
-            for (int ribbon : ribbons) {
-                cnt += ribbon / mid;
+            for (int x : ribbons) {
+                cnt += x / mid;
             }
-            if (cnt < k) {
-                high = mid - 1;
+            if (cnt >= k) {
+                left = mid;
             } else {
-                low = mid;
+                right = mid - 1;
             }
         }
-        return low;
+        return left;
     }
 }
 ```
 
-### **JavaScript**
-
-```js
-/**
- * @param {number[]} ribbons
- * @param {number} k
- * @return {number}
- */
-var maxLength = function (ribbons, k) {
-    let low = 0;
-    let high = 100000;
-    while (low < high) {
-        const mid = (low + high + 1) >> 1;
-        let cnt = 0;
-        for (let ribbon of ribbons) {
-            cnt += Math.floor(ribbon / mid);
-        }
-        if (cnt < k) {
-            high = mid - 1;
-        } else {
-            low = mid;
-        }
-    }
-    return low;
-};
-```
-
 ### **C++**
 
 ```cpp
 class Solution {
 public:
     int maxLength(vector<int>& ribbons, int k) {
-        int low = 0, high = 100000;
-        while (low < high) {
-            int mid = (low + high + 1) / 2;
+        int left = 0, right = 1e5;
+        while (left < right) {
+            int mid = (left + right + 1) >> 1;
             int cnt = 0;
-            for (auto ribbon : ribbons) {
+            for (int ribbon : ribbons) {
                 cnt += ribbon / mid;
             }
-            if (cnt < k) {
-                high = mid - 1;
+            if (cnt >= k) {
+                left = mid;
             } else {
-                low = mid;
+                right = mid - 1;
             }
         }
-        return low;
+        return left;
     }
 };
 ```
@@ -170,20 +149,69 @@ public:
 
 ```go
 func maxLength(ribbons []int, k int) int {
-	low, high := 0, 100000
-	for low < high {
-		mid := (low + high + 1) >> 1
+	left, right := 0, 100000
+	for left < right {
+		mid := (left + right + 1) >> 1
 		cnt := 0
-		for _, ribbon := range ribbons {
-			cnt += ribbon / mid
+		for _, x := range ribbons {
+			cnt += x / mid
 		}
-		if cnt < k {
-			high = mid - 1
+		if cnt >= k {
+			left = mid
 		} else {
-			low = mid
+			right = mid - 1
 		}
 	}
-	return low
+	return left
+}
+```
+
+### **JavaScript**
+
+```js
+/**
+ * @param {number[]} ribbons
+ * @param {number} k
+ * @return {number}
+ */
+var maxLength = function (ribbons, k) {
+    let left = 0;
+    let right = 1e5;
+    while (left < right) {
+        const mid = (left + right + 1) >> 1;
+        let cnt = 0;
+        for (const x of ribbons) {
+            cnt += Math.floor(x / mid);
+        }
+        if (cnt >= k) {
+            left = mid;
+        } else {
+            right = mid - 1;
+        }
+    }
+    return left;
+};
+```
+
+### **TypeScript**
+
+```ts
+function maxLength(ribbons: number[], k: number): number {
+    let left = 0;
+    let right = 1e5;
+    while (left < right) {
+        const mid = (left + right + 1) >> 1;
+        let cnt = 0;
+        for (const x of ribbons) {
+            cnt += Math.floor(x / mid);
+        }
+        if (cnt >= k) {
+            left = mid;
+        } else {
+            right = mid - 1;
+        }
+    }
+    return left;
 }
 ```