Related Articles

# Minimum steps to delete a string by deleting substring comprising of same characters

• Difficulty Level : Hard
• Last Updated : 28 May, 2021

Given a string str. You are allowed to delete only some contiguous characters if all the characters are same in a single operation. The task is to find the minimum number of operations required to completely delete the string.
Examples:

Input: str = “abcddcba”
Output:
Delete dd, then the string is “abccba”
Delete cc, then the string is “abba”
Delete bb, then the string is “aa”
Delete aa, then the string is null.
Input: str = “abc”
Output:

Approach: The problem can be solved using <a href=”http://wwl<=iDynamic Programming and Divide and Conquer technique.
Let dp[l][r] be the answer for sub-string s[l, l+1, l+2, …r]. Then we have two cases:

• The first letter of the sub-string is deleted separately from the rest, then dp[l][r] = 1 + dp[l+1][r].
• The first letter of the sub-string is deleted alongside with some other letter (both letters must be equal), then dp[l][r] = dp[l+1][i-1] + dp[i][r], given that l ≤ i ≤ r and s[i] = s[l].

The following two cases can be recursively called along with memoization to avoid repetitive function calls.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``const` `int` `N = 10;` `// Function to return the minimum number of``// delete operations``int` `findMinimumDeletion(``int` `l, ``int` `r, ``int` `dp[N][N], string s)``{` `    ``if` `(l > r)``        ``return` `0;``    ``if` `(l == r)``        ``return` `1;``    ``if` `(dp[l][r] != -1)``        ``return` `dp[l][r];` `    ``// When a single character is deleted``    ``int` `res = 1 + findMinimumDeletion(l + 1, r, dp, s);` `    ``// When a group of consecutive characters``    ``// are deleted if any of them matches``    ``for` `(``int` `i = l + 1; i <= r; ++i) {` `        ``// When both the characters are same then``        ``// delete the letters in between them``        ``if` `(s[l] == s[i])``            ``res = min(res, findMinimumDeletion(l + 1, i - 1, dp, s)``                               ``+ findMinimumDeletion(i, r, dp, s));``    ``}` `    ``// Memoize``    ``return` `dp[l][r] = res;``}` `// Driver code``int` `main()``{``    ``string s = ``"abcddcba"``;``    ``int` `n = s.length();``    ``int` `dp[N][N];``    ``memset``(dp, -1, ``sizeof` `dp);``    ``cout << findMinimumDeletion(0, n - 1, dp, s);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `    ``static` `int` `N = ``10``;` `    ``// Function to return the minimum number of``    ``// delete operations``    ``static` `int` `findMinimumDeletion(``int` `l, ``int` `r,``                            ``int` `dp[][], String s)``    ``{` `        ``if` `(l > r)``        ``{``            ``return` `0``;``        ``}``        ``if` `(l == r)``        ``{``            ``return` `1``;``        ``}``        ``if` `(dp[l][r] != -``1``)``        ``{``            ``return` `dp[l][r];``        ``}` `        ``// When a single character is deleted``        ``int` `res = ``1` `+ findMinimumDeletion(l + ``1``, r, dp, s);` `        ``// When a group of consecutive characters``        ``// are deleted if any of them matches``        ``for` `(``int` `i = l + ``1``; i <= r; ++i)``        ``{` `            ``// When both the characters are same then``            ``// delete the letters in between them``            ``if` `(s.charAt(l) == s.charAt(i))``            ``{``                ``res = Math.min(res, findMinimumDeletion(l + ``1``, i - ``1``, dp, s)``                        ``+ findMinimumDeletion(i, r, dp, s));``            ``}``        ``}` `        ``// Memoize``        ``return` `dp[l][r] = res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String s = ``"abcddcba"``;``        ``int` `n = s.length();``        ``int` `dp[][] = ``new` `int``[N][N];``        ``for` `(``int` `i = ``0``; i < N; i++)``        ``{``            ``for` `(``int` `j = ``0``; j < N; j++)``            ``{``                ``dp[i][j] = -``1``;``            ``}``        ``}``        ``System.out.println(findMinimumDeletion(``0``, n - ``1``, dp, s));``    ``}``}` `// This code contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of the approach` `# Function to return the minimum``# number of delete operations``def` `findMinimumDeletion(l, r, dp, s):` `    ``if` `l > r:``        ``return` `0``    ``if` `l ``=``=` `r:``        ``return` `1``    ``if` `dp[l][r] !``=` `-``1``:``        ``return` `dp[l][r]` `    ``# When a single character is deleted``    ``res ``=` `1` `+` `findMinimumDeletion(l ``+` `1``, r,``                                     ``dp, s)` `    ``# When a group of consecutive characters``    ``# are deleted if any of them matches``    ``for` `i ``in` `range``(l ``+` `1``, r ``+` `1``):` `        ``# When both the characters are same then``        ``# delete the letters in between them``        ``if` `s[l] ``=``=` `s[i]:``            ``res ``=` `min``(res, findMinimumDeletion(l ``+` `1``, i ``-` `1``, dp, s) ``+``                           ``findMinimumDeletion(i, r, dp, s))``    ` `    ``# Memoize``    ``dp[l][r] ``=` `res``    ``return` `res` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``s ``=` `"abcddcba"``    ``n ``=` `len``(s)``    ``N ``=` `10``    ``dp ``=` `[[``-``1` `for` `i ``in` `range``(N)]``              ``for` `j ``in` `range``(N)]``    ``print``(findMinimumDeletion(``0``, n ``-` `1``, dp, s))` `# This code is contributed by Rituraj Jain`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `    ``static` `int` `N = 10;` `    ``// Function to return the minimum number of``    ``// delete operations``    ``static` `int` `findMinimumDeletion(``int` `l, ``int` `r,``                            ``int` `[,]dp, String s)``    ``{` `        ``if` `(l > r)``        ``{``            ``return` `0;``        ``}``        ``if` `(l == r)``        ``{``            ``return` `1;``        ``}``        ``if` `(dp[l, r] != -1)``        ``{``            ``return` `dp[l, r];``        ``}` `        ``// When a single character is deleted``        ``int` `res = 1 + findMinimumDeletion(l + 1, r, dp, s);` `        ``// When a group of consecutive characters``        ``// are deleted if any of them matches``        ``for` `(``int` `i = l + 1; i <= r; ++i)``        ``{` `            ``// When both the characters are same then``            ``// delete the letters in between them``            ``if` `(s[l] == s[i])``            ``{``                ``res = Math.Min(res, findMinimumDeletion(l + 1, i - 1, dp, s)``                        ``+ findMinimumDeletion(i, r, dp, s));``            ``}``        ``}` `        ``// Memoize``        ``return` `dp[l,r] = res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String s = ``"abcddcba"``;``        ``int` `n = s.Length;``        ``int` `[,]dp = ``new` `int``[N, N];``        ``for` `(``int` `i = 0; i < N; i++)``        ``{``            ``for` `(``int` `j = 0; j < N; j++)``            ``{``                ``dp[i, j] = -1;``            ``}``        ``}``        ``Console.WriteLine(findMinimumDeletion(0, n - 1, dp, s));``    ``}``}` `// This code has been contributed by 29AjayKumar`

## PHP

 ` ``\$r``)``        ``return` `0;``    ``if` `(``\$l` `== ``\$r``)``        ``return` `1;``    ``if` `(``\$dp``[``\$l``][``\$r``] != -1)``        ``return` `\$dp``[``\$l``][``\$r``];` `    ``// When a single character is deleted``    ``\$res` `= 1 + findMinimumDeletion(``\$l` `+ 1, ``\$r``,``                                      ``\$dp``, ``\$s``);` `    ``// When a group of consecutive characters``    ``// are deleted if any of them matches``    ``for` `(``\$i` `= ``\$l` `+ 1; ``\$i` `<= ``\$r``; ++``\$i``)``    ``{` `        ``// When both the characters are same then``        ``// delete the letters in between them``        ``if` `(``\$s``[``\$l``] == ``\$s``[``\$i``])``            ``\$res` `= min(``\$res``, findMinimumDeletion(``\$l` `+ 1, ``\$i` `- 1, ``\$dp``, ``\$s``) +``                             ``findMinimumDeletion(``\$i``, ``\$r``, ``\$dp``, ``\$s``));``    ``}` `    ``// Memoize``    ``return` `\$dp``[``\$l``][``\$r``] = ``\$res``;``}` `// Driver code``\$s` `= ``"abcddcba"``;``\$n` `= ``strlen``(``\$s``);``\$dp` `= ``array``(``array``());``for``(``\$i` `= 0; ``\$i` `< ``\$GLOBALS``[``'N'``]; ``\$i``++)``    ``for``(``\$j` `= 0; ``\$j` `< ``\$GLOBALS``[``'N'``]; ``\$j``++)``        ``\$dp``[``\$i``][``\$j``] = -1 ;``        ` `echo` `findMinimumDeletion(0, ``\$n` `- 1, ``\$dp``, ``\$s``);` `// This code is contributed by Ryuga``?>`

## Javascript

 ``
Output:
`4`

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