Longest subsegment of ‘1’s formed by changing at most k ‘0’s | Set 2 (Using Queue)
Last Updated :
07 Feb, 2023
Given a binary array a[] and a number k, we need to find the length of the longest subsegment of ‘1’s possible by changing at most k ‘0’s.
Examples:
Input: a[] = {1, 0, 0, 1, 1, 0, 1}, k = 1
Output: 4
Explanation: Here, we should only change 1 zero(0). Maximum possible length we can get is by changing the 3rd zero in the array, we get a[] = {1, 0, 0, 1, 1, 1, 1}
Input: a[] = {1, 0, 0, 1, 0, 1, 0, 1, 0, 1}, k = 2
Output: 5
Two Pointer Approach: Refer the Set 1 of this article for the implementation of Two-pointer approach.
Queue Approach: The task can be solved with the help of a queue. Store the indices of 0s encountered so far in a queue. For each 0, check if the value of K is greater than 0 or not, if it is non-zero, flip it to 1, and maximize the subsegment length correspondingly, else shift the left pointer (initially at the start index of the string) to the index of first zero (queue's front) + 1.
Follow the below steps to solve the problem:
- Declare a queue for storing Indices of 0s Visited.
- Iterate over the string and If the current character is 0 and some spells are left i.e. (k != 0) then use the spell i.e. (decrement k). Also, store the index of "0" occurred.
- If k = 0, Take out the front of the queue and store it in a variable.
- Store the length as max between i-low and that of the previous answer.
- Shift low to index of first "0" + 1 and increment k.
- Finally, return the answer.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to Find longest subsegment of 1s
int get(int n, int k, int arr[])
{
// Queue for storing indices of 0s
queue<int> q;
int low = 0;
int ans = INT_MIN;
int p = k;
int i = 0;
while (i < n) {
// If the current character is 1
// then increment i by 1
if (arr[i] == 1) {
i++;
}
// If the current character is 0
// and some spells are
// left then use them
else if (arr[i] == 0 && k != 0) {
q.push(i);
k--;
i++;
}
// If k == 0
else {
// Take out the index where
// the first "0" was found
int x = q.front();
q.pop();
// Store the length as max
// between i-low and that
// of the previous answer
ans = max(ans, i - low);
// Shift low to index
// of first "O" + 1
low = x + 1;
// Increase spell by 1
k++;
}
// Store the length between
// the i-low and that of
// previous answer
ans = max(ans, i - low);
}
return ans;
}
// Driver Code
int main()
{
int N = 10;
int K = 2;
int arr[] = { 1, 0, 0, 1, 0,
1, 0, 1, 0, 1 };
cout << get(N, K, arr) << endl;
return 0;
}
// Java program for the above approach
import java.util.LinkedList;
import java.util.Queue;
class GFG{
// Function to Find longest subsegment of 1s
static int get(int n, int k, int arr[])
{
// Queue for storing indices of 0s
Queue<Integer> q = new LinkedList<Integer>();
int low = 0;
int ans = Integer.MIN_VALUE;
int i = 0;
while (i < n)
{
// If the current character is 1
// then increment i by 1
if (arr[i] == 1)
{
i++;
}
// If the current character is 0
// and some spells are
// left then use them
else if (arr[i] == 0 && k != 0)
{
q.add(i);
k--;
i++;
}
// If k == 0
else
{
// Take out the index where
// the first "0" was found
int x = q.peek();
q.remove();
// Store the length as max
// between i-low and that
// of the previous answer
ans = Math.max(ans, i - low);
// Shift low to index
// of first "O" + 1
low = x + 1;
// Increase spell by 1
k++;
}
// Store the length between
// the i-low and that of
// previous answer
ans = Math.max(ans, i - low);
}
return ans;
}
// Driver Code
public static void main(String args[])
{
int N = 10;
int K = 2;
int arr[] = { 1, 0, 0, 1, 0,
1, 0, 1, 0, 1 };
System.out.println(get(N, K, arr));
}
}
// This code is contributed by gfking
# Python code for the above approach
# Function to Find longest subsegment of 1s
def get(n, k, arr):
# Queue for storing indices of 0s
q = []
low = 0
ans = 10 ** -9
p = k
i = 0
while (i < n):
# If the current character is 1
# then increment i by 1
if (arr[i] == 1):
i += 1
# If the current character is 0
# and some spells are
# left then use them
elif (arr[i] == 0 and k != 0):
q.append(i)
k -= 1
i += 1
# If k == 0
else:
# Take out the index where
# the first "0" was found
x = q[0]
q.pop(0)
# Store the length as max
# between i-low and that
# of the previous answer
ans = max(ans, i - low)
# Shift low to index
# of first "O" + 1
low = x + 1
# Increase spell by 1
k += 1
# Store the length between
# the i-low and that of
# previous answer
ans = max(ans, i - low)
return ans
# Driver Code
N = 10
K = 2
arr = [1, 0, 0, 1, 0, 1, 0, 1, 0, 1]
print(get(N, K, arr))
# This code is contributed by Saurabh Jaiswal
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {
// Function to Find longest subsegment of 1s
static int get(int n, int k, int[] arr)
{
// Queue for storing indices of 0s
Queue<int> q = new Queue<int>();
int low = 0;
int ans = Int32.MinValue;
int i = 0;
while (i < n) {
// If the current character is 1
// then increment i by 1
if (arr[i] == 1) {
i++;
}
// If the current character is 0
// and some spells are
// left then use them
else if (arr[i] == 0 && k != 0) {
q.Enqueue(i);
k--;
i++;
}
// If k == 0
else {
// Take out the index where
// the first "0" was found
int x = q.Peek();
q.Dequeue();
// Store the length as max
// between i-low and that
// of the previous answer
ans = Math.Max(ans, i - low);
// Shift low to index
// of first "O" + 1
low = x + 1;
// Increase spell by 1
k++;
}
// Store the length between
// the i-low and that of
// previous answer
ans = Math.Max(ans, i - low);
}
return ans;
}
// Driver Code
public static void Main()
{
int N = 10;
int K = 2;
int[] arr = { 1, 0, 0, 1, 0, 1, 0, 1, 0, 1 };
Console.WriteLine(get(N, K, arr));
}
}
// This code is contributed by ukasp.
<script>
// JavaScript code for the above approach
// Function to Find longest subsegment of 1s
function get(n, k, arr) {
// Queue for storing indices of 0s
let q = [];
let low = 0;
let ans = Number.MIN_VALUE;
let p = k;
let i = 0;
while (i < n) {
// If the current character is 1
// then increment i by 1
if (arr[i] == 1) {
i++;
}
// If the current character is 0
// and some spells are
// left then use them
else if (arr[i] == 0 && k != 0) {
q.push(i);
k--;
i++;
}
// If k == 0
else {
// Take out the index where
// the first "0" was found
let x = q[0];
q.shift();
// Store the length as max
// between i-low and that
// of the previous answer
ans = Math.max(ans, i - low);
// Shift low to index
// of first "O" + 1
low = x + 1;
// Increase spell by 1
k++;
}
// Store the length between
// the i-low and that of
// previous answer
ans = Math.max(ans, i - low);
}
return ans;
}
// Driver Code
let N = 10;
let K = 2;
let arr = [1, 0, 0, 1, 0,
1, 0, 1, 0, 1];
document.write(get(N, K, arr) + '<br>');
// This code is contributed by Potta Lokesh
</script>
Time Complexity: O(N)
Auxiliary Space: O(k)
Related Topic: Subarrays, Subsequences, and Subsets in Array
Similar Reads
Longest substring of 0s in a string formed by k concatenations Given a binary string of length n and an integer k. Consider another string T which is formed by concatenating the given binary string k times. The task is to print the maximum size of a substring of T containing only zeroes. Examples: Input: str = 110010, k = 3 Output: 2 str = 110010 T = 1100101100
8 min read
Minimize count of 0s in Binary String by changing K-size substring to 1s at most Q times Given a binary string S having N characters and two integers K and Q, the task is to find the minimum number of remaining zeroes after at most Q operations, such that in each operation, choose any substring of size at most K and change all its elements to 1. Example: Input: S = 000111, K = 2, Q = 1O
15+ min read
Longest Subsequence with same char as substrings and difference of frequency at most K Given a string S of length N containing small-case English alphabets and an integer K, the task is to find the maximum possible length of the subsequence of S such that: The frequency of each letter in the subsequence does not differ by more than K from the frequency of any other letter.For any lett
7 min read
Longest sub string of 0's in a binary string which is repeated K times Given binary string S of size N and a number K. The task is to find the Longest sub string of 0's in the string which is formed by repeating given string K times. Examples: Input : S = "100001" , K = 3 Output : 4 After repeating given string 3 time, string becomes 100001100001100001. The longest sub
5 min read
LCS formed by consecutive segments of at least length K Given two strings s1, s2 and K, find the length of the longest subsequence formed by consecutive segments of at least length K. Examples: Input : s1 = aggayxysdfa s2 = aggajxaaasdfa k = 4 Output : 8 Explanation: aggasdfa is the longest subsequence that can be formed by taking consecutive segments, m
9 min read