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:4

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

**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 repetative function calls.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `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; ` `} ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP implementation of the approach ` `$GLOBALS` `[` `'N'` `] = 10; ` ` ` `// Function to return the minimum ` `// number of delete operations ` `function` `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` `= ` `$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 ` `?> ` |

*chevron_right*

*filter_none*

**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.

## Recommended Posts:

- Minimum steps to remove substring 010 from a binary string
- Minimum steps to delete a string after repeated deletion of palindrome substrings
- Minimum number of steps needed to remove the substring K from given string
- Find largest word in dictionary by deleting some characters of given string
- Minimum characters to be replaced to remove the given substring
- Minimum length substring with exactly K distinct characters
- Minimum time to write characters using insert, delete and copy operation
- Searching characters and substring in a String in Java
- Find the String having each substring with exactly K distinct characters
- Longest substring of only 4's from the first N characters of the infinite string
- Find the longest substring with k unique characters in a given string
- Number of Positions to partition the string such that atleast m characters with same frequency are present in each substring
- Minimum changes required to make first string substring of second string
- Find minimum number of steps to reach the end of String
- Minimum steps to convert one binary string to other only using negation
- Minimum deletions from string to reduce it to string with at most 2 unique characters
- Minimum splits in a binary string such that every substring is a power of 4 or 6.
- Minimum flips required in a binary string such that all K-size substring contains 1
- Generate a string of size N whose each substring of size M has exactly K distinct characters
- Longest suffix such that occurrence of each character is less than N after deleting atmost K characters

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.