Minimum operations to transform given string to another by moving characters to front or end - GeeksforGeeks

19 May, 2021
Given two Strings S and T of length N consisting of lowercase alphabets, which are permutations of each other, the task is to print the minimum number of operations to convert S to T. In one operation, pick any character of the string S and move it either to the start or end of the string S.
Examples:
Input: S = “abcde”, T = “edacb”Output: 3Explanation:We can convert S to T in 3 moves:1. move ‘d’ to start: “dabce” 2. move ‘e’ to start: “edabc” 3. move ‘b’ to end: “edacb”
Input: S = “dcdb”, T = “ddbc”Output: 1Explanation:Move ‘c’ to end
Naive Approach: The naive approach is to try all possibilities of swapping a character. One can put some character to the front, to the end, or can leave it in the same position. The above three operations can be solved using recursion and print the minimum number of steps required after all the steps.Time Complexity: O(3N), where N is the length of the given string.Auxiliary Space: O(1)
Efficient Approach: To optimize the above approach, the idea is to observe that after moving the characters of the string S, the unchanged characters come together to form a contiguous substring in T. So, if we can maximize the length of this subsequence, then the count of operations to convert string S to T is:
N – length of the longest contiguous substring of T that is a subsequence of S
Therefore, to find the length of the longest contiguous substring of T that is a subsequence of string S, find the longest common subsequence of S and T. Let dp[][] stores the length of the longest contiguous substring of T that is a subsequence of string S, . Now dp[i][j] will store the length of the longest suffix of T[0, ..., j] that is also a subsequence of S[0, ..., i]. The recurrence relation is given by: 
If i is greater than 0, dp[i][j] = max(dp[i-1][j], dp[i][j]).
If S[i] is equals to T[i] then, dp[i][j] = 1 + dp[i-1][j-1].
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; int dp[1010][1010]; // Function that finds the minimum number// of steps to find the minimum characters// must be moved to convert string s to tint solve(string s, string t){     int n = s.size();     // r = maximum value over all    // dp[i][j] computed so far    int r = 0;     // dp[i][j] stores the longest    // contiguous suffix of T[0..j]    // that is subsequence of S[0..i]    for (int i = 0; i < n; i++) {         for (int j = 0; j < n; j++) {             dp[i][j] = 0;            if (i > 0) {                 dp[i][j] = max(dp[i - 1][j],                               dp[i][j]);            }            if (s[i] == t[j]) {                 int ans = 1;                if (i > 0 && j > 0) {                     ans = 1 + dp[i - 1][j - 1];                }                 // Update the maximum length                dp[i][j] = max(dp[i][j], ans);                r = max(r, dp[i][j]);            }        }    }     // Return the resulting length    return (n - r);} // Driver Codeint main(){    // Given string s, t    string s = "abcde";    string t = "edacb";     // Function Call    cout << solve(s, t);    return 0;}
// Java program for the above approachclass GFG{    static int[][] dp = new int[1010][1010];     // Function that finds the minimum number    // of steps to find the minimum characters    // must be moved to convert String s to t    static int solve(String s, String t)    {        int n = s.length();         // r = maximum value over all        // dp[i][j] computed so far        int r = 0;         // dp[i][j] stores the longest        // contiguous suffix of T[0..j]        // that is subsequence of S[0..i]        for (int i = 0; i < n; i++)        {            for (int j = 0; j < n; j++)            {                dp[i][j] = 0;                if (i > 0)                {                    dp[i][j] = Math.max(dp[i - 1][j],                                        dp[i][j]);                }                if (s.charAt(i) == t.charAt(j))                {                    int ans = 1;                    if (i > 0 && j > 0)                    {                        ans = 1 + dp[i - 1][j - 1];                    }                     // Update the maximum length                    dp[i][j] = Math.max(dp[i][j], ans);                    r = Math.max(r, dp[i][j]);                }            }        }         // Return the resulting length        return (n - r);    }     // Driver Code    public static void main(String[] args)    {        // Given String s, t        String s = "abcde";        String t = "edacb";         // Function Call        System.out.print(solve(s, t));    }} // This code is contributed by shikhasingrajput
# Python3 program for the above approachdp = [[0] * 1010] * 1010 # Function that finds the minimum number# of steps to find the minimum characters# must be moved to convert string s to tdef solve(s, t):     n = len(s)     # r = maximum value over all    # dp[i][j] computed so far    r = 0     # dp[i][j] stores the longest    # contiguous suffix of T[0..j]    # that is subsequence of S[0..i]    for j in range(0, n):        for i in range(0, n):            dp[i][j] = 0                         if (i > 0):                dp[i][j] = max(dp[i - 1][j],                               dp[i][j])                         if (s[i] == t[j]):                ans = 1                if (i > 0 and j > 0):                    ans = 1 + dp[i - 1][j - 1]                                 # Update the maximum length                dp[i][j] = max(dp[i][j], ans)                r = max(r, dp[i][j])                     # Return the resulting length    return (n - r) # Driver Code # Given string s, ts = "abcde"t = "edacb" # Function callprint(solve(s, t)) # This code is contributed by code_hunt
// C# program for the above approachusing System;class GFG{static int[, ] dp = new int[1010, 1010]; // Function that finds the minimum number// of steps to find the minimum characters// must be moved to convert String s to tstatic int solve(String s, String t){    int n = s.Length;     // r = maximum value over all    // dp[i, j] computed so far    int r = 0;     // dp[i, j] stores the longest    // contiguous suffix of T[0..j]    // that is subsequence of S[0..i]    for (int i = 0; i < n; i++)    {        for (int j = 0; j < n; j++)        {            dp[i, j] = 0;            if (i > 0)            {                dp[i, j] = Math.Max(dp[i - 1, j],                                    dp[i, j]);            }            if (s[i] == t[j])            {                int ans = 1;                if (i > 0 && j > 0)                {                    ans = 1 + dp[i - 1, j - 1];                }                 // Update the maximum length                dp[i, j] = Math.Max(dp[i, j], ans);                r = Math.Max(r, dp[i, j]);            }        }    }     // Return the resulting length    return (n - r);} // Driver Codepublic static void Main(String[] args){            // Given String s, t    String s = "abcde";    String t = "edacb";     // Function Call    Console.Write(solve(s, t));}} // This code is contributed by shikhasingrajput
<script> // Javascript program for the above approach var dp = Array.from(Array(1010), ()=> Array(1010)); // Function that finds the minimum number// of steps to find the minimum characters// must be moved to convert string s to tfunction solve(s, t){     var n = s.length;     // r = maximum value over all    // dp[i][j] computed so far    var r = 0;     // dp[i][j] stores the longest    // contiguous suffix of T[0..j]    // that is subsequence of S[0..i]    for (var i = 0; i < n; i++) {         for (var j = 0; j < n; j++) {             dp[i][j] = 0;            if (i > 0) {                 dp[i][j] = Math.max(dp[i - 1][j],                               dp[i][j]);            }            if (s[i] == t[j]) {                 var ans = 1;                if (i > 0 && j > 0) {                     ans = 1 + dp[i - 1][j - 1];                }                 // Update the maximum length                dp[i][j] = Math.max(dp[i][j], ans);                r = Math.max(r, dp[i][j]);            }        }    }     // Return the resulting length    return (n - r);} // Driver Code// Given string s, tvar s = "abcde";var t = "edacb";// Function Calldocument.write( solve(s, t)); </script>
3
Time Complexity: O(N2), where N is the length of the given stringAuxiliary Space: O(N2)
Note: The above naive approach is efficient for smaller strings whereas, the above efficient approach is efficient for larger strings. 
shikhasingrajput
code_hunt
rutvik_56
LCS
substring
Dynamic Programming
Strings
Strings
Dynamic Programming
LCS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Subset Sum Problem | DP-25
Coin Change | DP-7
Matrix Chain Multiplication | DP-8
Write a program to reverse an array or string
Reverse a string in Java
C++ Data Types
Check for Balanced Brackets in an expression (well-formedness) using Stack
Python program to check if a string is palindrome or not