Open in App
Not now

# Minimum number of swaps required such that a given substring consists of exactly K 1s

• Last Updated : 29 Oct, 2021

Given a binary string S of size N and three positive integers L, R, and K, the task is to find the minimum number of swaps required to such that the substring {S[L], .. S[R]} consists of exactly K 1s. If it is not possible to do so, then print “-1”.

Examples:

Input: S = “110011111000101”, L = 5, R = 8, K = 2
Output: 2
Explanation:
Initially, the substring {S[5], .. S[8]} = “1111” consists of 4 1s.
Swap (S[5], S[3]) and (S[6], S[4]).
Modified string S = “111100111000101” and {S[5], .. S[8]} = “0011”.
Therefore, 2 swaps are required.

Input: S = “01010101010101”, L = 3, R = 7, K = 8
Output: -1

Approach: The idea is to count the number of 1s and 0s present in the substring and outside the substring, {S[L], …, S[R]}. Then, check if enough 1s or 0s are present outside that range which can be swapped such that the substring contains exactly K 1s.

Follow the steps below to solve the problem:

• Store the frequency of 1s and 0s in the string S in cntOnes and cntZeros respectively.
• Also, store the frequency of 1s and 0s in the substring S[L, R] in ones and zeros respectively.
• Find the frequency of 1s and 0s outside the substring S[L, R] using the formula: (rem_ones = cntOnes – ones) and rem_zero = (cntZeros – zeros).
• If k â‰¥ ones, then do the following:
• Initialize rem = (K – ones), which denotes the number of 1s required to make the sum equal to K.
• If zeros â‰¥ rem and rem_ones â‰¥ rem, print the value of rem as the result.
• Otherwise, if K < ones, then do the following:
• Initialize rem = (ones – K), which denotes the number of 0s required to make the sum equal to K.
• If ones â‰¥ rem and rem_zeros â‰¥ rem, print the value of rem as the result.
• In all other cases, print -1.

Below is the implementation of the above approach:

## C++

 `// CPP program for the above approach` `#include` `using` `namespace` `std;`   `    ``// Function to find the minimum number` `    ``// of swaps required such that the` `    ``// substring {s[l], .., s[r]} consists` `    ``// of exactly k 1s` `   ``int` `minimumSwaps(string s, ``int` `l, ``int` `r, ``int` `k)` `    ``{` `     `  `        ``// Store the size of the string` `        ``int` `n = s.length();`   `        ``// Store the total number of 1s` `        ``// and 0s in the entire string` `        ``int` `tot_ones = 0, tot_zeros = 0;`   `        ``// Traverse the string S to find` `        ``// the frequency of 1 and 0` `        ``for` `(``int` `i = 0; i < s.length(); i++) ` `        ``{` `            ``if` `(s[i] == ``'1'``)` `                ``tot_ones++;` `            ``else` `                ``tot_zeros++;` `        ``}`   `        ``// Store the number of 1s and` `        ``// 0s in the substring s[l, r]` `        ``int` `ones = 0, zeros = 0, sum = 0;`   `        ``// Traverse the substring S[l, r]` `        ``// to find the frequency of 1s` `        ``// and 0s in it` `        ``for` `(``int` `i = l - 1; i < r; i++) ` `        ``{` `            ``if` `(s[i] == ``'1'``)` `            ``{` `                ``ones++;` `                ``sum++;` `            ``}` `            ``else` `                ``zeros++;` `        ``}`   `        ``// Store the count of 1s and` `        ``// 0s outside substring s[l, r]` `        ``int` `rem_ones = tot_ones - ones;` `        ``int` `rem_zeros = tot_zeros - zeros;`   `        ``// Check if the sum of the` `        ``// substring is at most K` `        ``if` `(k >= sum)` `        ``{`   `            ``// Store number of 1s required` `            ``int` `rem = k - sum;`   `            ``// Check if there are enough 1s` `            ``// remaining to be swapped` `            ``if` `(zeros >= rem && rem_ones >= rem)` `                ``return` `rem;` `        ``}`   `        ``// If the count of 1s in the substring exceeds k` `        ``else` `if` `(k < sum)` `        ``{`   `            ``// Store the number of 0s required` `            ``int` `rem = sum - k;`   `            ``// Check if there are enough 0s` `            ``// remaining to be swapped` `            ``if` `(ones >= rem && rem_zeros >= rem)` `                ``return` `rem;` `        ``}`   `        ``// In all other cases, print -1` `        ``return` `-1;` `    ``}`   `    ``// Driver Code` `    ``int` `main()` `    ``{` `        ``string S = ``"110011111000101"``;` `        ``int` `L = 5, R = 8, K = 2;` `        ``cout<

## Java

 `// Java program for the above approach`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find the minimum number` `    ``// of swaps required such that the` `    ``// substring {s[l], .., s[r]} consists` `    ``// of exactly k 1s` `    ``static` `int` `minimumSwaps(` `        ``String s, ``int` `l, ``int` `r, ``int` `k)` `    ``{` `        ``// Store the size of the string` `        ``int` `n = s.length();`   `        ``// Store the total number of 1s` `        ``// and 0s in the entire string` `        ``int` `tot_ones = ``0``, tot_zeros = ``0``;`   `        ``// Traverse the string S to find` `        ``// the frequency of 1 and 0` `        ``for` `(``int` `i = ``0``; i < s.length(); i++) {` `            ``if` `(s.charAt(i) == ``'1'``)` `                ``tot_ones++;` `            ``else` `                ``tot_zeros++;` `        ``}`   `        ``// Store the number of 1s and` `        ``// 0s in the substring s[l, r]` `        ``int` `ones = ``0``, zeros = ``0``, sum = ``0``;`   `        ``// Traverse the substring S[l, r]` `        ``// to find the frequency of 1s` `        ``// and 0s in it` `        ``for` `(``int` `i = l - ``1``; i < r; i++) {` `            ``if` `(s.charAt(i) == ``'1'``) {` `                ``ones++;` `                ``sum++;` `            ``}` `            ``else` `                ``zeros++;` `        ``}`   `        ``// Store the count of 1s and` `        ``// 0s outside substring s[l, r]` `        ``int` `rem_ones = tot_ones - ones;` `        ``int` `rem_zeros = tot_zeros - zeros;`   `        ``// Check if the sum of the` `        ``// substring is at most K` `        ``if` `(k >= sum) {`   `            ``// Store number of 1s required` `            ``int` `rem = k - sum;`   `            ``// Check if there are enough 1s` `            ``// remaining to be swapped` `            ``if` `(zeros >= rem && rem_ones >= rem)` `                ``return` `rem;` `        ``}`   `        ``// If the count of 1s in the substring exceeds k` `        ``else` `if` `(k < sum) {`   `            ``// Store the number of 0s required` `            ``int` `rem = sum - k;`   `            ``// Check if there are enough 0s` `            ``// remaining to be swapped` `            ``if` `(ones >= rem && rem_zeros >= rem)` `                ``return` `rem;` `        ``}`   `        ``// In all other cases, print -1` `        ``return` `-``1``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String S = ``"110011111000101"``;` `        ``int` `L = ``5``, R = ``8``, K = ``2``;` `        ``System.out.println(` `            ``minimumSwaps(S, L, R, K));` `    ``}` `}`

## Python3

 `# Python3 program for the above approach`   `# Function to find the minimum number` `# of swaps required such that the` `# substring {s[l], .., s[r]} consists` `# of exactly k 1s` `def` `minimumSwaps(s, l, r, k) :`   `    ``# Store the size of the string` `    ``n ``=` `len``(s)`   `    ``# Store the total number of 1s` `    ``# and 0s in the entire string` `    ``tot_ones, tot_zeros ``=` `0``, ``0`   `    ``# Traverse the string S to find` `    ``# the frequency of 1 and 0` `    ``for` `i ``in` `range``(``0``, ``len``(s)) :` `    `  `        ``if` `(s[i] ``=``=` `'1'``) :` `            ``tot_ones ``+``=` `1` `        ``else` `:` `            ``tot_zeros ``+``=` `1`   `    ``# Store the number of 1s and` `    ``# 0s in the substring s[l, r]` `    ``ones, zeros, ``Sum` `=` `0``, ``0``, ``0`   `    ``# Traverse the substring S[l, r]` `    ``# to find the frequency of 1s` `    ``# and 0s in it` `    ``for` `i ``in` `range``(l ``-` `1``, r) :` `    `  `        ``if` `(s[i] ``=``=` `'1'``) :` `        `  `            ``ones ``+``=` `1` `            ``Sum` `+``=` `1` `        `  `        ``else` `:` `            ``zeros ``+``=` `1`   `    ``# Store the count of 1s and` `    ``# 0s outside substring s[l, r]` `    ``rem_ones ``=` `tot_ones ``-` `ones` `    ``rem_zeros ``=` `tot_zeros ``-` `zeros`   `    ``# Check if the sum of the` `    ``# substring is at most K` `    ``if` `(k >``=` `Sum``) :`   `        ``# Store number of 1s required` `        ``rem ``=` `k ``-` `Sum`   `        ``# Check if there are enough 1s` `        ``# remaining to be swapped` `        ``if` `(zeros >``=` `rem ``and` `rem_ones >``=` `rem) :` `            ``return` `rem`   `    ``# If the count of 1s in the substring exceeds k` `    ``elif` `(k < ``Sum``) :`   `        ``# Store the number of 0s required` `        ``rem ``=` `Sum` `-` `k`   `        ``# Check if there are enough 0s` `        ``# remaining to be swapped` `        ``if` `(ones >``=` `rem ``and` `rem_zeros >``=` `rem) :` `            ``return` `rem`   `    ``# In all other cases, print -1` `    ``return` `-``1`   `S ``=` `"110011111000101"` `L, R, K ``=` `5``, ``8``, ``2` `print``(minimumSwaps(S, L, R, K))`   `# This code is contributed by divyeshrabadiya07.`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `class` `GFG` `{`   `  ``// Function to find the minimum number` `  ``// of swaps required such that the` `  ``// substring {s[l], .., s[r]} consists` `  ``// of exactly k 1s` `  ``static` `int` `minimumSwaps(``string` `s, ``int` `l, ``int` `r, ``int` `k)` `  ``{`   `    ``// Store the size of the string` `    ``int` `n = s.Length;`   `    ``// Store the total number of 1s` `    ``// and 0s in the entire string` `    ``int` `tot_ones = 0, tot_zeros = 0;`   `    ``// Traverse the string S to find` `    ``// the frequency of 1 and 0` `    ``for` `(``int` `i = 0; i < s.Length; i++) ` `    ``{` `      ``if` `(s[i] == ``'1'``)` `        ``tot_ones++;` `      ``else` `        ``tot_zeros++;` `    ``}`   `    ``// Store the number of 1s and` `    ``// 0s in the substring s[l, r]` `    ``int` `ones = 0, zeros = 0, sum = 0;`   `    ``// Traverse the substring S[l, r]` `    ``// to find the frequency of 1s` `    ``// and 0s in it` `    ``for` `(``int` `i = l - 1; i < r; i++) ` `    ``{` `      ``if` `(s[i] == ``'1'``)` `      ``{` `        ``ones++;` `        ``sum++;` `      ``}` `      ``else` `        ``zeros++;` `    ``}`   `    ``// Store the count of 1s and` `    ``// 0s outside substring s[l, r]` `    ``int` `rem_ones = tot_ones - ones;` `    ``int` `rem_zeros = tot_zeros - zeros;`   `    ``// Check if the sum of the` `    ``// substring is at most K` `    ``if` `(k >= sum)` `    ``{`   `      ``// Store number of 1s required` `      ``int` `rem = k - sum;`   `      ``// Check if there are enough 1s` `      ``// remaining to be swapped` `      ``if` `(zeros >= rem && rem_ones >= rem)` `        ``return` `rem;` `    ``}`   `    ``// If the count of 1s in the substring exceeds k` `    ``else` `if` `(k < sum)` `    ``{`   `      ``// Store the number of 0s required` `      ``int` `rem = sum - k;`   `      ``// Check if there are enough 0s` `      ``// remaining to be swapped` `      ``if` `(ones >= rem && rem_zeros >= rem)` `        ``return` `rem;` `    ``}`   `    ``// In all other cases, print -1` `    ``return` `-1;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``string` `S = ``"110011111000101"``;` `    ``int` `L = 5, R = 8, K = 2;` `    ``Console.Write(minimumSwaps(S, L, R, K));` `  ``}` `}`   `// This code is contributed by splevel62.`

## Javascript

 ``

Output:

`2`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles