 Open in App
Not now

# Minimize cost of swapping set bits with unset bits in a given Binary string

• Last Updated : 05 Dec, 2022

Given a binary string S of size N, the task is to find the minimum cost by swapping every set bit with an unset bit such that the cost of swapping pairs of bits at indices i and j is abs(j – i).

Note: A swapped bit can’t be swapped twice and the count of set bit in the given binary string is at most N/2.

Examples:

Input: S = “1010001”
Output: 3
Explanation:
Following the swapping of characters required:

1. Swap characters at indices (0, 1) modifies the string to “0110001” and the cost of this operation is |1 – 0| = 1.
2. Swap characters at indices (2, 3) modifies the string to “0101001” and the cost of this operation is |2 – 1| = 1.
3. Swap characters at indices (6, 7) modifies the string to “0101010” and the cost of this operation is |7 – 6| = 1.

After the above operations, all the set bits is replaced with unset bits and the total cost of operations is 1 + 1 + 1 = 3.

Input: S = “1100”
Output: 4

Approach: The given problem can be solved using Dynamic Programming by storing the indices of set and unset bits in two auxiliary arrays, say A[] and B[], and then find the sum of the difference between array elements A[] with any element of the array B[]. Follow the steps below to solve the given problem:

• Initialize two arrays, say A[] and B[], and store the indices of set and unset bits in it.
• Initialize a 2D array, dp[][] of dimensions K*(N – K) where K is the count of set bit in S such thatdp[i][j] stores the minimum cost of swapping the ith array element A[] with the jth array element B[].
• Now, for each state there are two choices:
1. Swap the ith array element A[] till the (j – 1)th array element B[] as dp[i][j] = dp[i][j – 1].
2. Swap the (i – 1)th array element A[] till the (j – 1)th array element B[] and the ith array element A[] with jth array element B[] and this state can be calculated as dp[i][j] = dp[i – 1][j – 1] + abs(A[i] – B[i]).
• Now, choose the minimum of the above two choices to find the current state as:

dp[i][j] = min(dp[i][j-1], dp[i-1][j-1] + abs(A[i] – B[j]))

• After completing the above steps, print the value of dp[K][N – K] as the resultant minimum number of operations.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;``#define INF 1000000000` `// Function to find the minimum cost``// required to swap every set bit with``// an unset bit``int` `minimumCost(string s)``{``    ``int` `N = s.length();` `    ``// Stores the indices of set and``    ``// unset bits of the string S``    ``vector<``int``> A, B;` `    ``// Traverse the string S``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Store the indices``        ``if` `(s[i] == ``'1'``) {``            ``A.push_back(i);``        ``}``        ``else` `{``            ``B.push_back(i);``        ``}``    ``}` `    ``int` `n1 = A.size();``    ``int` `n2 = B.size();` `    ``// Initialize a dp table of size``    ``// n1*n2``    ``int` `dp[n1 + 1][n2 + 1];` `    ``// Initialize all states to 0``    ``memset``(dp, 0, ``sizeof``(dp));` `    ``// Set unreachable states to INF``    ``for` `(``int` `i = 1; i <= n1; i++) {``        ``dp[i] = INF;``    ``}` `    ``// Fill the dp Table according to``    ``// the given recurrence relation``    ``for` `(``int` `i = 1; i <= n1; i++) {``        ``for` `(``int` `j = 1; j <= n2; j++) {` `            ``// Update the value of``            ``// dp[i][j]``            ``dp[i][j] = min(``                ``dp[i][j - 1],``                ``dp[i - 1][j - 1]``                    ``+ ``abs``(A[i - 1] - B[j - 1]));``        ``}``    ``}` `    ``// Return the minimum cost``    ``return` `dp[n1][n2];``}` `// Driver Code``int` `main()``{``    ``string S = ``"1010001"``;``    ``cout << minimumCost(S);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``static` `final` `int` `INF = ``1000000000``;` `// Function to find the minimum cost``// required to swap every set bit with``// an unset bit``static` `int` `minimumCost(String s)``{``    ``int` `N = s.length();` `    ``// Stores the indices of set and``    ``// unset bits of the String S``    ``Vector A = ``new` `Vector();``    ``Vector B = ``new` `Vector();` `    ``// Traverse the String S``    ``for` `(``int` `i = ``0``; i < N; i++) {` `        ``// Store the indices``        ``if` `(s.charAt(i) == ``'1'``) {``            ``A.add(i);``        ``}``        ``else` `{``            ``B.add(i);``        ``}``    ``}` `    ``int` `n1 = A.size();``    ``int` `n2 = B.size();` `    ``// Initialize a dp table of size``    ``// n1*n2``    ``int` `[][]dp = ``new` `int``[n1 + ``1``][n2 + ``1``];`  `    ``// Set unreachable states to INF``    ``for` `(``int` `i = ``1``; i <= n1; i++) {``        ``dp[i][``0``] = INF;``    ``}` `    ``// Fill the dp Table according to``    ``// the given recurrence relation``    ``for` `(``int` `i = ``1``; i <= n1; i++) {``        ``for` `(``int` `j = ``1``; j <= n2; j++) {` `            ``// Update the value of``            ``// dp[i][j]``            ``dp[i][j] = Math.min(``                ``dp[i][j - ``1``],``                ``dp[i - ``1``][j - ``1``]``                    ``+ Math.abs(A.get(i - ``1``) - B.get(j - ``1``)));``        ``}``    ``}` `    ``// Return the minimum cost``    ``return` `dp[n1][n2];``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String S = ``"1010001"``;``    ``System.out.print(minimumCost(S));``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python program for the above approach``INF ``=` `1000000000` `# Function to find the minimum cost``# required to swap every set bit with``# an unset bit`  `def` `minimumCost(s):``    ``N ``=` `len``(s)` `    ``# Stores the indices of set and``    ``# unset bits of the string S``    ``A ``=` `[]``    ``B ``=` `[]` `    ``# Traverse the string S``    ``for` `i ``in` `range``(``0``, N):` `        ``# Store the indices``        ``if` `(s[i] ``=``=` `"1"``):``            ``A.append(i)``        ``else``:``            ``B.append(i)` `    ``n1 ``=` `len``(A)``    ``n2 ``=` `len``(B)` `    ``# Initialize a dp table of size``    ``# n1*n2``    ``dp ``=` `[[``0` `for` `i ``in` `range``(n2 ``+` `1``)] ``for` `j ``in` `range``(n1 ``+` `1``)]` `    ``# Set unreachable states to INF``    ``for` `i ``in` `range``(``1``, n1 ``+` `1``):``        ``dp[i][``0``] ``=` `INF` `    ``# Fill the dp Table according to``    ``# the given recurrence relation``    ``for` `i ``in` `range``(``1``, n1 ``+` `1``):``        ``for` `j ``in` `range``(``1``, n2 ``+` `1``):` `            ``# Update the value of``            ``# dp[i][j]``            ``dp[i][j] ``=` `min``(``                ``dp[i][j ``-` `1``],``                ``dp[i ``-` `1``][j ``-` `1``] ``+` `abs``(A[i ``-` `1``] ``-` `B[j ``-` `1``])``            ``)` `    ``# Return the minimum cost``    ``return` `dp[n1][n2]`  `# Driver Code``S ``=` `"1010001"``print``(minimumCost(S))` `# This code is contributed by _saurabh_jaiswal.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;``                    ` `public` `class` `Program``{``  ` `// Function to find the minimum cost``// required to swap every set bit with``// an unset bit``static` `int` `minimumCost(``string` `s)``{``    ``int` `INF = 1000000000;``    ``int` `N = s.Length;` `    ``// Stores the indices of set and``    ``// unset bits of the string S``    ``List<``int``> A = ``new` `List<``int``>();``    ``List<``int``> B = ``new` `List<``int``>();` `    ``// Traverse the string S``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Store the indices``        ``if` `(s[i] == ``'1'``) {``            ``A.Add(i);``        ``}``        ``else` `{``            ``B.Add(i);``        ``}``    ``}` `    ``int` `n1 = A.Count;``    ``int` `n2 = B.Count;` `    ``// Initialize a dp table of size``    ``// n1*n2``    ``int` `[,]dp = ``new`  `int``[n1 + 1,n2 + 1];`  `    ``// Set unreachable states to INF``    ``for` `(``int` `i = 1; i <= n1; i++) {``        ``dp[i,0] = INF;``    ``}` `    ``// Fill the dp Table according to``    ``// the given recurrence relation``    ``for` `(``int` `i = 1; i <= n1; i++) {``        ``for` `(``int` `j = 1; j <= n2; j++) {` `            ``// Update the value of``            ``// dp[i][j]``            ``dp[i,j] = Math.Min(``                ``dp[i,j - 1],``                ``dp[i - 1,j - 1]``                    ``+ Math.Abs(A[i - 1] - B[j - 1]));``        ``}``    ``}` `    ``// Return the minimum cost``    ``return` `dp[n1,n2];``}``    ` `    ``public` `static` `void` `Main()``    ``{``        ``string` `S = ``"1010001"``;``        ``Console.Write(minimumCost(S));``    ``}``}` `// This code is contributed by rutvik_56.`

## Javascript

 ``

Output:

`3`

Time Complexity: O(K*(N – K)) where K is the count of set bit in S.
Auxiliary Space: O(K*(N – K))

My Personal Notes arrow_drop_up