feat: add solutions to lc problems: No.3095~3097 (#2523)

* No.3095.Shortest Subarray With OR at Least K I
* No.3096.Minimum Levels to Gain More Points
* No.3097.Shortest Subarray With OR at Least K II

Author: yanglbme

solution/3000-3099/3095.Shortest Subarray With OR at Least K I/README.md

@@ -66,6 +66,16 @@
 
 ### 方法一：双指针 + 计数
 
+我们可以发现，如果我们固定子数组的左端点，随着右端点向右移动，子数组的按位或值只会增大，不会减小。因此我们可以使用双指针的方法，维护一个满足条件的子数组。
+
+具体地，我们使用两个指针 $i$ 和 $j$ 分别表示子数组的左右端点，初始时两个指针都位于数组的第一个元素。用一个变量 $s$ 表示子数组的按位或值，初始时 $s$ 的值为 $0$。我们还需要维护一个长度为 $32$ 的数组 $cnt$，表示子数组中每个元素的二进制表示中每一位的出现次数。
+
+在每一步操作中，我们将 $j$ 向右移动一位，更新 $s$ 和 $cnt$。如果 $s$ 的值大于等于 $k$，我们不断更新子数组的最小长度，并将 $i$ 向右移动一位，直到 $s$ 的值小于 $k$。在这个过程中，我们也需要更新 $s$ 和 $cnt$。
+
+最后，我们返回最小长度，如果不存在满足条件的子数组，则返回 $-1$。
+
+时间复杂度 $O(n \times \log M)$，空间复杂度 $O(\log M)$，其中 $n$ 和 $M$ 分别是数组的长度和数组中元素的最大值。
+
 <!-- tabs:start -->
 
 ```python

solution/3000-3099/3095.Shortest Subarray With OR at Least K I/README_EN.md

@@ -60,7 +60,17 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Two Pointers + Counting
+
+We can observe that if we fix the left endpoint of the subarray, as the right endpoint moves to the right, the bitwise OR value of the subarray will only increase, not decrease. Therefore, we can use the double pointers method to maintain a subarray that meets the conditions.
+
+Specifically, we use two pointers $i$ and $j$ to represent the left and right endpoints of the subarray, respectively. Initially, both pointers are at the first element of the array. We use a variable $s$ to represent the bitwise OR value of the subarray, and initially, the value of $s$ is $0$. We also need to maintain an array $cnt$ of length $32$, which represents the occurrence times of each bit in the binary representation of each element in the subarray.
+
+In each step, we move $j$ to the right by one position, and update $s$ and $cnt$. If the value of $s$ is greater than or equal to $k$, we continuously update the minimum length of the subarray and move $i$ to the right by one position until the value of $s$ is less than $k$. In this process, we also need to update $s$ and $cnt$.
+
+Finally, we return the minimum length. If there is no subarray that meets the conditions, we return $-1$.
+
+The time complexity is $O(n \times \log M)$ and the space complexity is $O(\log M)$, where $n$ and $M$ are the length of the array and the maximum value of the elements in the array, respectively.
 
 <!-- tabs:start -->
 

solution/3000-3099/3096.Minimum Levels to Gain More Points/README.md

@@ -86,24 +86,104 @@
 
 ## 解法
 
-### 方法一
+### 方法一：枚举
+
+我们先计算得到两个玩家能得到的分数和，记为 $s$。
+
+然后我们从小到大枚举玩家 $1$ 能完成的关卡数目 $i$，计算玩家 $1$ 得到的分数和 $t$，如果 $t > s - t$，那么玩家 $1$ 需要完成的关卡数目就是 $i$。
+
+如果枚举完前 $n - 1$ 个关卡都没有找到满足条件的 $i$，那么就返回 $-1$。
+
+时间复杂度 $O(n)$，其中 $n$ 是数组的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def minimumLevels(self, possible: List[int]) -> int:
+        s = sum(-1 if x == 0 else 1 for x in possible)
+        t = 0
+        for i, x in enumerate(possible[:-1], 1):
+            t += -1 if x == 0 else 1
+            if t > s - t:
+                return i
+        return -1
 ```
 
 ```java
-
+class Solution {
+    public int minimumLevels(int[] possible) {
+        int s = 0;
+        for (int x : possible) {
+            s += x == 0 ? -1 : 1;
+        }
+        int t = 0;
+        for (int i = 1; i < possible.length; ++i) {
+            t += possible[i - 1] == 0 ? -1 : 1;
+            if (t > s - t) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    int minimumLevels(vector<int>& possible) {
+        int s = 0;
+        for (int x : possible) {
+            s += x == 0 ? -1 : 1;
+        }
+        int t = 0;
+        for (int i = 1; i < possible.size(); ++i) {
+            t += possible[i - 1] == 0 ? -1 : 1;
+            if (t > s - t) {
+                return i;
+            }
+        }
+        return -1;
+    }
+};
 ```
 
 ```go
+func minimumLevels(possible []int) int {
+	s := 0
+	for _, x := range possible {
+		if x == 0 {
+			x = -1
+		}
+		s += x
+	}
+	t := 0
+	for i, x := range possible[:len(possible)-1] {
+		if x == 0 {
+			x = -1
+		}
+		t += x
+		if t > s-t {
+			return i + 1
+		}
+	}
+	return -1
+}
+```
 
+```ts
+function minimumLevels(possible: number[]): number {
+    const s = possible.reduce((acc, x) => acc + (x === 0 ? -1 : 1), 0);
+    let t = 0;
+    for (let i = 1; i < possible.length; ++i) {
+        t += possible[i - 1] === 0 ? -1 : 1;
+        if (t > s - t) {
+            return i;
+        }
+    }
+    return -1;
+}
 ```
 
 <!-- tabs:end -->

solution/3000-3099/3096.Minimum Levels to Gain More Points/README_EN.md

@@ -82,24 +82,104 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Enumeration
+
+First, we calculate the sum of the scores that both players can get, denoted as $s$.
+
+Then, we enumerate the number of levels that player 1 can complete, denoted as $i$, in ascending order. We calculate the sum of the scores that player 1 gets, denoted as $t$. If $t > s - t$, then the number of levels that player 1 needs to complete is $i$.
+
+If we have enumerated the first $n - 1$ levels and have not found a satisfying $i$, then we return $-1$.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def minimumLevels(self, possible: List[int]) -> int:
+        s = sum(-1 if x == 0 else 1 for x in possible)
+        t = 0
+        for i, x in enumerate(possible[:-1], 1):
+            t += -1 if x == 0 else 1
+            if t > s - t:
+                return i
+        return -1
 ```
 
 ```java
-
+class Solution {
+    public int minimumLevels(int[] possible) {
+        int s = 0;
+        for (int x : possible) {
+            s += x == 0 ? -1 : 1;
+        }
+        int t = 0;
+        for (int i = 1; i < possible.length; ++i) {
+            t += possible[i - 1] == 0 ? -1 : 1;
+            if (t > s - t) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    int minimumLevels(vector<int>& possible) {
+        int s = 0;
+        for (int x : possible) {
+            s += x == 0 ? -1 : 1;
+        }
+        int t = 0;
+        for (int i = 1; i < possible.size(); ++i) {
+            t += possible[i - 1] == 0 ? -1 : 1;
+            if (t > s - t) {
+                return i;
+            }
+        }
+        return -1;
+    }
+};
 ```
 
 ```go
+func minimumLevels(possible []int) int {
+	s := 0
+	for _, x := range possible {
+		if x == 0 {
+			x = -1
+		}
+		s += x
+	}
+	t := 0
+	for i, x := range possible[:len(possible)-1] {
+		if x == 0 {
+			x = -1
+		}
+		t += x
+		if t > s-t {
+			return i + 1
+		}
+	}
+	return -1
+}
+```
 
+```ts
+function minimumLevels(possible: number[]): number {
+    const s = possible.reduce((acc, x) => acc + (x === 0 ? -1 : 1), 0);
+    let t = 0;
+    for (let i = 1; i < possible.length; ++i) {
+        t += possible[i - 1] === 0 ? -1 : 1;
+        if (t > s - t) {
+            return i;
+        }
+    }
+    return -1;
+}
 ```
 
 <!-- tabs:end -->

solution/3000-3099/3096.Minimum Levels to Gain More Points/Solution.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int minimumLevels(vector<int>& possible) {
+        int s = 0;
+        for (int x : possible) {
+            s += x == 0 ? -1 : 1;
+        }
+        int t = 0;
+        for (int i = 1; i < possible.size(); ++i) {
+            t += possible[i - 1] == 0 ? -1 : 1;
+            if (t > s - t) {
+                return i;
+            }
+        }
+        return -1;
+    }
+};

solution/3000-3099/3096.Minimum Levels to Gain More Points/Solution.go

@@ -0,0 +1,20 @@
+func minimumLevels(possible []int) int {
+	s := 0
+	for _, x := range possible {
+		if x == 0 {
+			x = -1
+		}
+		s += x
+	}
+	t := 0
+	for i, x := range possible[:len(possible)-1] {
+		if x == 0 {
+			x = -1
+		}
+		t += x
+		if t > s-t {
+			return i + 1
+		}
+	}
+	return -1
+}

solution/3000-3099/3096.Minimum Levels to Gain More Points/Solution.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int minimumLevels(int[] possible) {
+        int s = 0;
+        for (int x : possible) {
+            s += x == 0 ? -1 : 1;
+        }
+        int t = 0;
+        for (int i = 1; i < possible.length; ++i) {
+            t += possible[i - 1] == 0 ? -1 : 1;
+            if (t > s - t) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

solution/3000-3099/3096.Minimum Levels to Gain More Points/Solution.py

@@ -0,0 +1,9 @@
+class Solution:
+    def minimumLevels(self, possible: List[int]) -> int:
+        s = sum(-1 if x == 0 else 1 for x in possible)
+        t = 0
+        for i, x in enumerate(possible[:-1], 1):
+            t += -1 if x == 0 else 1
+            if t > s - t:
+                return i
+        return -1

solution/3000-3099/3096.Minimum Levels to Gain More Points/Solution.ts

@@ -0,0 +1,11 @@
+function minimumLevels(possible: number[]): number {
+    const s = possible.reduce((acc, x) => acc + (x === 0 ? -1 : 1), 0);
+    let t = 0;
+    for (let i = 1; i < possible.length; ++i) {
+        t += possible[i - 1] === 0 ? -1 : 1;
+        if (t > s - t) {
+            return i;
+        }
+    }
+    return -1;
+}

solution/3000-3099/3097.Shortest Subarray With OR at Least K II/README.md

@@ -64,7 +64,17 @@
 
 ## 解法
 
-### 方法一
+### 方法一：双指针 + 计数
+
+我们可以发现，如果我们固定子数组的左端点，随着右端点向右移动，子数组的按位或值只会增大，不会减小。因此我们可以使用双指针的方法，维护一个满足条件的子数组。
+
+具体地，我们使用两个指针 $i$ 和 $j$ 分别表示子数组的左右端点，初始时两个指针都位于数组的第一个元素。用一个变量 $s$ 表示子数组的按位或值，初始时 $s$ 的值为 $0$。我们还需要维护一个长度为 $32$ 的数组 $cnt$，表示子数组中每个元素的二进制表示中每一位的出现次数。
+
+在每一步操作中，我们将 $j$ 向右移动一位，更新 $s$ 和 $cnt$。如果 $s$ 的值大于等于 $k$，我们不断更新子数组的最小长度，并将 $i$ 向右移动一位，直到 $s$ 的值小于 $k$。在这个过程中，我们也需要更新 $s$ 和 $cnt$。
+
+最后，我们返回最小长度，如果不存在满足条件的子数组，则返回 $-1$。
+
+时间复杂度 $O(n \times \log M)$，空间复杂度 $O(\log M)$，其中 $n$ 和 $M$ 分别是数组的长度和数组中元素的最大值。
 
 <!-- tabs:start -->