Minimum operations to transform given string to another

Minimum operations to transform given string to another

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

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:_ 3_

Explanation:

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:_ 1_

Explanation:

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 recursionand 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++

// 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 t

**int** 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 Code

**int** main()

{

// Given string s, t

string s = "abcde"``;

string t = "edacb"``;

// Function Call

cout << solve(s, t);

**return** 0;

}

Output:

3

Time Complexity:_ O(N2), where N is the length of the given string_

Auxiliary Space:_ O(N2)_

Note: The above naive approach is efficient for smaller strings whereas, the above efficient approach is efficient for larger strings.

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.

dynamic programming strings lcs substring

Bootstrap 5 Complete Course with Examples

Bootstrap 5 Tutorial - Bootstrap 5 Crash Course for Beginners

Nest.JS Tutorial for Beginners

Hello Vue 3: A First Look at Vue 3 and the Composition API

Building a simple Applications with Vue 3

Deno Crash Course: Explore Deno and Create a full REST API with Deno

How to Build a Real-time Chat App with Deno and WebSockets

Convert HTML to Markdown Online

HTML entity encoder decoder Online

Check if given string is a substring of string formed

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

Count of Distinct Substrings occurring consecutively in a given String

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

Smallest String consisting of a String S exactly K times as a Substring

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

All You Need to Know About Dynamic Programming

In this article, I will introduce the concept of dynamic programming, developed by Richard Bellman in the 1950s, a powerful algorithm design technique to solve problems by breaking them down into smaller

An Introduction to Dynamic Programming

An Introduction to Dynamic Programming: Although people make a big deal about how scary dynamic programming problems are, there’s really no need to be afraid of them.