feat: add solutions for lc No.3857~3859 (#5058)

Author: yanglbme

solution/3800-3899/3857.Minimum Cost to Split into Ones/README.md

@@ -135,32 +135,59 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3857.Mi
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：数学
+
+要使得代价最小，我们首先要将 $n$ 拆分成 $1$ 和 $n-1$，代价为 $1 \cdot (n-1) = n-1$。接下来，我们将 $n-1$ 拆分成 $1$ 和 $n-2$，代价为 $1 \cdot (n-2) = n-2$。
+
+继续这个过程，直到我们将 $2$ 拆分成 $1$ 和 $1$，代价为 $1 \cdot 1 = 1$。因此，总代价为 $(n-1) + (n-2) + \ldots + 2 + 1 = \frac{n(n-1)}{2}$。
+
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def minCost(self, n: int) -> int:
+        return n * (n - 1) // 2
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int minCost(int n) {
+        return n * (n - 1) / 2;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int minCost(int n) {
+        return n * (n - 1) / 2;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func minCost(n int) int {
+	return n * (n - 1) / 2
+}
+```
+
+#### TypeScript
 
+```ts
+function minCost(n: number): number {
+    return (n * (n - 1)) >> 1;
+}
 ```
 
 <!-- tabs:end -->

solution/3800-3899/3857.Minimum Cost to Split into Ones/README_EN.md

@@ -132,32 +132,59 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3857.Mi
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Math
+
+To minimize the total cost, we first split $n$ into $1$ and $n-1$, with a cost of $1 \cdot (n-1) = n-1$. Next, we split $n-1$ into $1$ and $n-2$, with a cost of $1 \cdot (n-2) = n-2$.
+
+We continue this process until we split $2$ into $1$ and $1$, with a cost of $1 \cdot 1 = 1$. Therefore, the total cost is $(n-1) + (n-2) + \ldots + 2 + 1 = \frac{n(n-1)}{2}$.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def minCost(self, n: int) -> int:
+        return n * (n - 1) // 2
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int minCost(int n) {
+        return n * (n - 1) / 2;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int minCost(int n) {
+        return n * (n - 1) / 2;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func minCost(n int) int {
+	return n * (n - 1) / 2
+}
+```
+
+#### TypeScript
 
+```ts
+function minCost(n: number): number {
+    return (n * (n - 1)) >> 1;
+}
 ```
 
 <!-- tabs:end -->

solution/3800-3899/3857.Minimum Cost to Split into Ones/Solution.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+    int minCost(int n) {
+        return n * (n - 1) / 2;
+    }
+};

solution/3800-3899/3857.Minimum Cost to Split into Ones/Solution.go

@@ -0,0 +1,3 @@
+func minCost(n int) int {
+	return n * (n - 1) / 2
+}

solution/3800-3899/3857.Minimum Cost to Split into Ones/Solution.java

@@ -0,0 +1,5 @@
+class Solution {
+    public int minCost(int n) {
+        return n * (n - 1) / 2;
+    }
+}

solution/3800-3899/3857.Minimum Cost to Split into Ones/Solution.py

@@ -0,0 +1,3 @@
+class Solution:
+    def minCost(self, n: int) -> int:
+        return n * (n - 1) // 2

solution/3800-3899/3857.Minimum Cost to Split into Ones/Solution.ts

@@ -0,0 +1,3 @@
+function minCost(n: number): number {
+    return (n * (n - 1)) >> 1;
+}

solution/3800-3899/3858.Minimum Bitwise OR From Grid/README.md

@@ -91,25 +91,162 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3858.Mi
 #### Python3
 
 ```python
-
+class Solution:
+    def minimumOR(self, grid: List[List[int]]) -> int:
+        mx = max(map(max, grid))
+        m = mx.bit_length()
+        ans = 0
+        for i in range(m - 1, -1, -1):
+            mask = ans | ((1 << i) - 1)
+            for row in grid:
+                found = False
+                for x in row:
+                    if (x | mask) == mask:
+                        found = True
+                        break
+                if not found:
+                    ans |= 1 << i
+                    break
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int minimumOR(int[][] grid) {
+        int mx = 0;
+        for (int[] row : grid) {
+            for (int x : row) {
+                mx = Math.max(mx, x);
+            }
+        }
+
+        int m = 32 - Integer.numberOfLeadingZeros(mx);
+        int ans = 0;
+
+        for (int i = m - 1; i >= 0; i--) {
+            int mask = ans | ((1 << i) - 1);
+            for (int[] row : grid) {
+                boolean found = false;
+                for (int x : row) {
+                    if ((x | mask) == mask) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    ans |= 1 << i;
+                    break;
+                }
+            }
+        }
+
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int minimumOR(vector<vector<int>>& grid) {
+        int mx = 0;
+        for (auto& row : grid) {
+            mx = max(mx, ranges::max(row));
+        }
+
+        int m = 32 - __builtin_clz(mx);
+        int ans = 0;
+
+        for (int i = m - 1; i >= 0; i--) {
+            int mask = ans | ((1 << i) - 1);
+            for (auto& row : grid) {
+                bool found = false;
+                for (int x : row) {
+                    if ((x | mask) == mask) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    ans |= 1 << i;
+                    break;
+                }
+            }
+        }
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func minimumOR(grid [][]int) int {
+	mx := 0
+	for _, row := range grid {
+		mx = max(mx, slices.Max(row))
+	}
+
+	m := bits.Len(uint(mx))
+	ans := 0
+
+	for i := m - 1; i >= 0; i-- {
+		mask := ans | ((1 << i) - 1)
+		for _, row := range grid {
+			found := false
+			for _, x := range row {
+				if (x | mask) == mask {
+					found = true
+					break
+				}
+			}
+			if !found {
+				ans |= 1 << i
+				break
+			}
+		}
+	}
+
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function minimumOR(grid: number[][]): number {
+    let mx = 0;
+    for (const row of grid) {
+        mx = Math.max(mx, Math.max(...row));
+    }
+
+    const m = mx === 0 ? 0 : 32 - Math.clz32(mx);
+    let ans = 0;
+
+    for (let i = m - 1; i >= 0; i--) {
+        const mask = ans | ((1 << i) - 1);
+        for (const row of grid) {
+            let found = false;
+            for (const x of row) {
+                if ((x | mask) === mask) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                ans |= 1 << i;
+                break;
+            }
+        }
+    }
+
+    return ans;
+}
 ```
 
 <!-- tabs:end -->