Related Articles

# Minimum number of flips or swaps of adjacent characters required to make two strings equal

• Last Updated : 23 Aug, 2021

Given two binary strings A and B of length N, the task is to count the minimum number of operations required to make the two given strings equal by either swapping adjacent characters or flipping any character of the string A.

Examples:

Input: A = “100”, B = “001”
Output: 2
Explanation: Flipping characters A(= ‘1’) and A(= ‘0’) modifies the string A to “001”, which is equal to the string B.

Input: A = “0101”, B = “0011”
Output: 1
Explanation: Swapping the characters A(= ‘0’) and A(= ‘1’) modifies the string A to “0011”, which is equal to string B.

Approach: The problem can be solved using Dynamic Programming as it has Overlapping Subproblems and Optimal Substructure
Follow the steps below to solve the problem:

• Initialize an array, say dp[] of size N+1 as {0}, where dp[i] stores the minimum number of operations required up to index i, to make the prefix of Ai equal to the prefix Bi.
• Iterate over the range [1, N] using a variable, say i, and performing the following operations:
• If A[i – 1] equals B[i – 1], then update dp[i] to dp[i – 1].
• Otherwise, update dp[i] to dp[i – 1] + 1.
• If swapping is possible, i.e. i > 1 and A[i – 2] is equal to B[i – 1] and A[i – 1] is equal to B[i – 2], then update dp[i] to min(dp[i], dp[i – 2] + 1).
• After completing the above steps, print the minimum number of operations obtained, i.e. the value dp[N].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count the minimum``// number of operations required``// to make strings A and B equal``int` `countMinSteps(string A, string B, ``int` `N)``{` `    ``// Stores all dp-states``    ``vector<``int``> dp(N + 1, 0);` `    ``// Iterate over the range [1, N]``    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``// If A[i - 1] equals to B[i - 1]``        ``if` `(A[i - 1] == B[i - 1]) {` `            ``// Assign Dp[i - 1] to Dp[i]``            ``dp[i] = dp[i - 1];``        ``}` `        ``// Otherwise``        ``else` `{` `            ``// Update dp[i]``            ``dp[i] = dp[i - 1] + 1;``        ``}` `        ``// If swapping is possible``        ``if` `(i >= 2 && A[i - 2] == B[i - 1]``            ``&& A[i - 1] == B[i - 2]) {` `            ``// Update dp[i]``            ``dp[i] = min(dp[i], dp[i - 2] + 1);``        ``}``    ``}` `    ``// Return the minimum``    ``// number of steps required``    ``return` `dp[N];``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``string A = ``"0101"``;``    ``string B = ``"0011"``;``    ``int` `N = A.length();` `    ``// Function Call``    ``cout << countMinSteps(A, B, N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG{``    ` `// Function to count the minimum``// number of operations required``// to make strings A and B equal``static` `int` `countMinSteps(String A, String B, ``int` `N)``{``    ` `    ``// Stores all dp-states``    ``int``[] dp = ``new` `int``[N + ``1``];``    ``for``(``int` `i = ``1``; i <= N; i++)``    ``{``        ` `        ``// Update the value of A[i]``        ``dp[i] = ``0``;``    ``}` `    ``// Iterate over the range [1, N]``    ``for``(``int` `i = ``1``; i <= N; i++)``    ``{``        ` `        ``// If A[i - 1] equals to B[i - 1]``        ``if` `(A.charAt(i - ``1``) == B.charAt(i - ``1``))``        ``{``            ` `            ``// Assign Dp[i - 1] to Dp[i]``            ``dp[i] = dp[i - ``1``];``        ``}` `        ``// Otherwise``        ``else``        ``{``            ` `            ``// Update dp[i]``            ``dp[i] = dp[i - ``1``] + ``1``;``        ``}` `        ``// If swapping is possible``        ``if` `(i >= ``2` `&& A.charAt(i - ``2``) == B.charAt(i - ``1``) &&``                      ``A.charAt(i - ``1``) == B.charAt(i - ``2``))``        ``{``            ` `            ``// Update dp[i]``            ``dp[i] = Math.min(dp[i], dp[i - ``2``] + ``1``);``        ``}``    ``}` `    ``// Return the minimum``    ``// number of steps required``    ``return` `dp[N];``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given Input``    ``String A = ``"0101"``;``    ``String B = ``"0011"``;``    ``int` `N = A.length();``    ` `    ``// Function Call``    ``System.out.println(countMinSteps(A, B, N));``}``}` `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program for the above approach` `# Function to count the minimum``# number of operations required``# to make strings A and B equal``def` `countMinSteps(A, B, N) :` `    ``# Stores all dp-states``    ``dp ``=` `[``0``] ``*` `(N ``+` `1``)` `    ``# Iterate rate over the range [1, N]``    ``for` `i ``in` `range``(``1``, N``+``1``) :` `        ``# If A[i - 1] equals to B[i - 1]``        ``if` `(A[i ``-` `1``] ``=``=` `B[i ``-` `1``]) :` `            ``# Assign Dp[i - 1] to Dp[i]``            ``dp[i] ``=` `dp[i ``-` `1``]``        `  `        ``# Otherwise``        ``else` `:` `            ``# Update dp[i]``            ``dp[i] ``=` `dp[i ``-` `1``] ``+` `1``        `  `        ``# If swapping is possible``        ``if` `(i >``=` `2` `and` `A[i ``-` `2``] ``=``=` `B[i ``-` `1``]``            ``and` `A[i ``-` `1``] ``=``=` `B[i ``-` `2``]) :` `            ``# Update dp[i]``            ``dp[i] ``=` `min``(dp[i], dp[i ``-` `2``] ``+` `1``)``        ` `    ``# Return the minimum``    ``# number of steps required``    ``return` `dp[N]`  `# Driver Code` `# Given Input``A ``=` `"0101"``B ``=` `"0011"``N ``=` `len``(A)` `# Function Call``print``(countMinSteps(A, B, N))` `# This code is contributed by splevel62.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to count the minimum``// number of operations required``// to make strings A and B equal``static` `int` `countMinSteps(``string` `A, ``string` `B, ``int` `N)``{``    ` `    ``// Stores all dp-states``    ``int``[] dp = ``new` `int``[N + 1];``    ``for``(``int` `i = 1; i <= N; i++)``    ``{``        ` `        ``// Update the value of A[i]``        ``dp[i] = 0;``    ``}` `    ``// Iterate over the range [1, N]``    ``for``(``int` `i = 1; i <= N; i++)``    ``{``        ` `        ``// If A[i - 1] equals to B[i - 1]``        ``if` `(A[i - 1] == B[i - 1])``        ``{``            ` `            ``// Assign Dp[i - 1] to Dp[i]``            ``dp[i] = dp[i - 1];``        ``}` `        ``// Otherwise``        ``else``        ``{``            ` `            ``// Update dp[i]``            ``dp[i] = dp[i - 1] + 1;``        ``}` `        ``// If swapping is possible``        ``if` `(i >= 2 && A[i - 2] == B[i - 1] &&``                      ``A[i - 1] == B[i - 2])``        ``{``            ` `            ``// Update dp[i]``            ``dp[i] = Math.Min(dp[i], dp[i - 2] + 1);``        ``}``    ``}` `    ``// Return the minimum``    ``// number of steps required``    ``return` `dp[N];``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ` `    ``// Given Input``    ``string` `A = ``"0101"``;``    ``string` `B = ``"0011"``;``    ``int` `N = A.Length;` `    ``// Function Call``    ``Console.Write(countMinSteps(A, B, N));``}``}` `// This code is contributed by code_hunt`

## Javascript

 ``
Output:
`1`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up