feat: add 2nd ts solution to lc problem: No.0995

solution/0900-0999/0995.Minimum Number of K Consecutive Bit Flips/README.md

@@ -96,7 +96,7 @@ class Solution:
         ans = s = 0
         for i, x in enumerate(nums):
             s += d[i]
-            if x % 2 == s % 2:
+            if s % 2 == x:
                 if i + k > n:
                     return -1
                 d[i] += 1
@@ -116,7 +116,7 @@ class Solution {
         int ans = 0, s = 0;
         for (int i = 0; i < n; ++i) {
             s += d[i];
-            if (nums[i] % 2 == s % 2) {
+            if (s % 2 == nums[i]) {
                 if (i + k > n) {
                     return -1;
                 }
@@ -143,7 +143,7 @@ public:
         int ans = 0, s = 0;
         for (int i = 0; i < n; ++i) {
             s += d[i];
-            if (s % 2 == nums[i] % 2) {
+            if (s % 2 == nums[i]) {
                 if (i + k > n) {
                     return -1;
                 }
@@ -161,13 +161,13 @@ public:
 #### Go
 
 ```go
-func minKBitFlips(nums []int, k int) int {
+func minKBitFlips(nums []int, k int) (ans int) {
 	n := len(nums)
 	d := make([]int, n+1)
-	ans, s := 0, 0
+	s := 0
 	for i, x := range nums {
 		s += d[i]
-		if s%2 == x%2 {
+		if s%2 == x {
 			if i+k > n {
 				return -1
 			}
@@ -177,7 +177,7 @@ func minKBitFlips(nums []int, k int) int {
 			ans++
 		}
 	}
-	return ans
+	return
 }
 ```
 
@@ -190,7 +190,7 @@ function minKBitFlips(nums: number[], k: number): number {
     let [ans, s] = [0, 0];
     for (let i = 0; i < n; ++i) {
         s += d[i];
-        if (s % 2 === nums[i] % 2) {
+        if (s % 2 === nums[i]) {
             if (i + k > n) {
                 return -1;
             }
@@ -215,7 +215,7 @@ impl Solution {
         let mut s = 0;
         for i in 0..n {
             s += d[i];
-            if nums[i] % 2 == s % 2 {
+            if s % 2 == nums[i] {
                 if i + (k as usize) > n {
                     return -1;
                 }
@@ -234,4 +234,164 @@ impl Solution {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### 方法二：滑动窗口
+
+我们可以用一个变量 $\text{flipped}$ 来表示当前位置是否翻转，如果 $\text{flipped}$ 为 $1$，表示当前位置已经翻转，否则表示当前位置未翻转。对于翻转过的位置，我们可以将其值设置为 $-1$，这样我们就可以区分出哪些位置已经翻转过了。
+
+接下来我们从左到右遍历数组，对于每个位置 $i$，如果 $i \geq k$ 且 $i-k$ 位置的元素为 $-1$，那么当前位置的翻转状态应该与前一个位置的翻转状态相反。即 $\text{flipped} = \text{flipped} \oplus 1$。如果当前位置的元素与当前位置的翻转状态相同，那么我们需要翻转当前位置，此时我们判断一下 $i+k$ 是否超出了数组的长度，如果超出了数组的长度，那么就无法完成目标，返回 $-1$。否则我们将当前位置的翻转状态取反，同时将答案增加 $1$，并且将当前位置的元素设置为 $-1$。
+
+这样当我们处理完数组中的所有元素时，返回答案即可。
+
+时间复杂度 $O(n)$，其中 $n$ 是数组 $nums$ 的长度。空间复杂度 $O(1)$。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def minKBitFlips(self, nums: List[int], k: int) -> int:
+        ans = flipped = 0
+        for i, x in enumerate(nums):
+            if i >= k and nums[i - k] == -1:
+                flipped ^= 1
+            if x == flipped:
+                if i + k > len(nums):
+                    return -1
+                flipped ^= 1
+                ans += 1
+                nums[i] = -1
+        return ans
+```
+
+#### Java
+
+```java
+class Solution {
+    public int minKBitFlips(int[] nums, int k) {
+        int n = nums.length;
+        int ans = 0, flipped = 0;
+        for (int i = 0; i < n; ++i) {
+            if (i >= k && nums[i - k] == -1) {
+                flipped ^= 1;
+            }
+            if (flipped == nums[i]) {
+                if (i + k > n) {
+                    return -1;
+                }
+                flipped ^= 1;
+                ++ans;
+                nums[i] = -1;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int minKBitFlips(vector<int>& nums, int k) {
+        int n = nums.size();
+        int ans = 0, flipped = 0;
+        for (int i = 0; i < n; ++i) {
+            if (i >= k && nums[i - k] == -1) {
+                flipped ^= 1;
+            }
+            if (flipped == nums[i]) {
+                if (i + k > n) {
+                    return -1;
+                }
+                flipped ^= 1;
+                ++ans;
+                nums[i] = -1;
+            }
+        }
+        return ans;
+    }
+};
+```
+
+#### Go
+
+```go
+func minKBitFlips(nums []int, k int) (ans int) {
+	flipped := 0
+	for i, x := range nums {
+		if i >= k && nums[i-k] == -1 {
+			flipped ^= 1
+		}
+		if flipped == x {
+			if i+k > len(nums) {
+				return -1
+			}
+			flipped ^= 1
+			ans++
+			nums[i] = -1
+		}
+	}
+	return
+}
+```
+
+#### TypeScript
+
+```ts
+function minKBitFlips(nums: number[], k: number): number {
+    const n = nums.length;
+    let [ans, flipped] = [0, 0];
+    for (let i = 0; i < n; i++) {
+        if (nums[i - k] === -1) {
+            flipped ^= 1;
+        }
+        if (nums[i] === flipped) {
+            if (i + k > n) {
+                return -1;
+            }
+            flipped ^= 1;
+            ++ans;
+            nums[i] = -1;
+        }
+    }
+    return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn min_k_bit_flips(mut nums: Vec<i32>, k: i32) -> i32 {
+        let mut ans = 0;
+        let mut flipped = 0;
+        let k = k as usize;
+
+        for i in 0..nums.len() {
+            if i >= k && nums[i - k] == -1 {
+                flipped ^= 1;
+            }
+            if flipped == nums[i] {
+                if i + k > nums.len() {
+                    return -1;
+                }
+                flipped ^= 1;
+                ans += 1;
+                nums[i] = -1;
+            }
+        }
+
+        ans
+    }
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->