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[0], then flip A[2].
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[0],A[1],A[2]: A becomes [1,1,1,1,0,1,1,0] Flip A[4],A[5],A[6]: A becomes [1,1,1,1,1,0,0,0] Flip A[5],A[6],A[7]: A becomes [1,1,1,1,1,1,1,1]
Note:
1 <= A.length <= 300001 <= K <= A.lengthstruct 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);
}