## 995. Minimum Number of K Consecutive Bit Flips

In an array `A` containing only 0s and 1s, a `K`-bit flip consists of choosing a (contiguous) subarray of length `K` and simultaneously changing every 0 in the subarray to 1, and every 1 in the subarray to 0.

Return the minimum number of `K`-bit flips required so that there is no 0 in the array.  If it is not possible, return `-1`.

Example 1:

```Input: A = [0,1,0], K = 1
Output: 2
Explanation: Flip A, then flip A.
```

Example 2:

```Input: A = [1,1,0], K = 2
Output: -1
Explanation: No matter how we flip subarrays of size 2, we can't make the array become [1,1,1].
```

Example 3:

```Input: A = [0,0,0,1,0,1,1,0], K = 3
Output: 3
Explanation:
Flip A,A,A: A becomes [1,1,1,1,0,1,1,0]
Flip A,A,A: A becomes [1,1,1,1,1,0,0,0]
Flip A,A,A: A becomes [1,1,1,1,1,1,1,1]
```

Note:

1. `1 <= A.length <= 30000`
2. `1 <= K <= A.length`

## Rust Solution

``````struct Solution;

use std::collections::VecDeque;

impl Solution {
fn min_k_bit_flips(a: Vec<i32>, k: i32) -> i32 {
let n = a.len();
let k = k as usize;
let mut queue: VecDeque<usize> = VecDeque::new();
let mut res = 0;
for i in 0..n {
if let Some(&j) = queue.front() {
if j + k == i {
queue.pop_front().unwrap();
}
}
if i + k <= n {
if (queue.len() as i32 + a[i]) % 2 == 0 {
queue.push_back(i);
res += 1;
}
} else {
if (queue.len() as i32 + a[i]) % 2 == 0 {
return -1;
}
}
}
res
}
}

#[test]
fn test() {
let a = vec![0, 1, 0];
let k = 1;
let res = 2;
assert_eq!(Solution::min_k_bit_flips(a, k), res);
let a = vec![1, 1, 0];
let k = 2;
let res = -1;
assert_eq!(Solution::min_k_bit_flips(a, k), res);
let a = vec![0, 0, 0, 1, 0, 1, 1, 0];
let k = 3;
let res = 3;
assert_eq!(Solution::min_k_bit_flips(a, k), res);
}
``````

Having problems with this solution? Click here to submit an issue on github.