Related Articles

# Minimum steps to delete a string after repeated deletion of palindrome substrings

• Difficulty Level : Hard
• Last Updated : 26 Apr, 2021

Given a string containing characters as integers only. We need to delete all characters of this string in a minimum number of steps wherein one step we can delete the substring which is a palindrome. After deleting a substring remaining parts are concatenated.

Examples:

```Input : s = “2553432”
Output : 2
We can delete all character of above string in
2 steps, first deleting the substring s[3, 5] “343”
and then remaining string completely  s[0, 3] “2552”

Input : s = “1234”
Output : 4
We can delete all character of above string in 4
steps only because each character need to be deleted
separately. No substring of length 2 is a palindrome
in above string.```

We can solve this problem using Dynamic programming. Let dp[i][j] denotes the number of steps it takes to delete the substring s[i, j]. Each character will be deleted alone or as part of some substring so in the first case we will delete the character itself and call subproblem (i+1, j). In the second case, we will iterate the overall occurrence of the current character on the right side, if K is the index of one such occurrence then the problem will reduce to two subproblems (i+1, K – 1) and (K+1, j). We can reach this subproblem (i+1, K-1) because we can just delete the same character and call for the mid substring. We need to take care of a case when the first two characters are the same in that case we can directly reduce to the subproblem (i+2, j).
So after the above discussion of the relation among subproblems, we can write dp relation as follows,

```dp[i][j] = min(1 + dp[i+1][j],
dp[i+1][K-1] + dp[K+1][j],  where s[i] == s[K]
1 + dp[i+2][j] )```

The total time complexity of the above solution is O(n^3)

## C++

 `//  C++ program to find minimum step to delete a string``#include ``using` `namespace` `std;` `/* method returns minimum step for deleting the string,``   ``where in one step a palindrome is removed */``int` `minStepToDeleteString(string str)``{``    ``int` `N = str.length();` `    ``//  declare dp array and initialize it with 0s``    ``int` `dp[N + 1][N + 1];``    ``for` `(``int` `i = 0; i <= N; i++)``        ``for` `(``int` `j = 0; j <= N; j++)``            ``dp[i][j] = 0;` `    ``// loop for substring length we are considering``    ``for` `(``int` `len = 1; len <= N; len++)``    ``{``        ``// loop with two variables i and j, denoting``        ``// starting and ending of substrings``        ``for` `(``int` `i = 0, j = len - 1; j < N; i++, j++)``        ``{``            ``// If substring length is 1, then 1 step``            ``// will be needed``            ``if` `(len == 1)``                ``dp[i][j] = 1;``            ``else``            ``{``                ``// delete the ith char individually``                ``// and assign result for subproblem (i+1,j)``                ``dp[i][j] = 1 + dp[i + 1][j];` `                ``// if current and next char are same,``                ``// choose min from current and subproblem``                ``// (i+2,j)``                ``if` `(str[i] == str[i + 1])``                    ``dp[i][j] = min(1 + dp[i + 2][j], dp[i][j]);` `                ``/*  loop over all right characters and suppose``                    ``Kth char is same as ith character then``                    ``choose minimum from current and two``                    ``substring after ignoring ith and Kth char */``                ``for` `(``int` `K = i + 2; K <= j; K++)``                    ``if` `(str[i] == str[K])``                        ``dp[i][j] = min(dp[i+1][K-1] + dp[K+1][j],``                                                       ``dp[i][j]);``            ``}``        ``}``    ``}` `    ``/* Uncomment below snippet to print actual dp tablex``    ``for (int i = 0; i < N; i++, cout << endl)``        ``for (int j = 0; j < N; j++)``            ``cout << dp[i][j] << " ";    */` `    ``return` `dp[N - 1];``}` `//  Driver code to test above methods``int` `main()``{``    ``string str = ``"2553432"``;``    ``cout << minStepToDeleteString(str) << endl;``    ``return` `0;``}`

## Java

 `// Java program to find minimum step to``// delete a string``public` `class` `GFG``{                           ``    ``/* method returns minimum step for deleting``       ``the string, where in one step a``       ``palindrome is removed``     ``*/``    ``static` `int` `minStepToDeleteString(String str) {``        ``int` `N = str.length();` `        ``// declare dp array and initialize it with 0s``        ``int``[][] dp = ``new` `int``[N + ``1``][N + ``1``];``        ``for` `(``int` `i = ``0``; i <= N; i++)``            ``for` `(``int` `j = ``0``; j <= N; j++)``                ``dp[i][j] = ``0``;` `        ``// loop for substring length we are considering``        ``for` `(``int` `len = ``1``; len <= N; len++) {``            ` `            ``// loop with two variables i and j, denoting``            ``// starting and ending of substrings``            ``for` `(``int` `i = ``0``, j = len - ``1``; j < N; i++, j++) {``    ` `                ``// If substring length is 1, then 1 step``                ``// will be needed``                ``if` `(len == ``1``)``                    ``dp[i][j] = ``1``;``                    ` `                ``else` `{``                    ``// delete the ith char individually``                    ``// and assign result for``                    ``// subproblem (i+1,j)``                    ``dp[i][j] = ``1` `+ dp[i + ``1``][j];` `                    ``// if current and next char are same,``                    ``// choose min from current and``                    ``// subproblem (i+2, j)``                    ``if` `(str.charAt(i) == str.charAt(i + ``1``))``                        ``dp[i][j] = Math.min(``1` `+ dp[i + ``2``][j],``                                               ``dp[i][j]);` `                    ``/* loop over all right characters and``                      ``suppose Kth char is same as ith``                      ``character then choose minimum from``                      ``current and two substring after``                      ``ignoring ith and Kth char``                     ``*/``                    ``for` `(``int` `K = i + ``2``; K <= j; K++)``                        ``if` `(str.charAt(i) == str.charAt(K))``                            ``dp[i][j] = Math.min(``                                         ``dp[i + ``1``][K - ``1``] +``                                        ``dp[K + ``1``][j], dp[i][j]);``                ``}``            ``}``        ``}` `        ``/* Uncomment below snippet to print actual dp tablex``         ` `           ``for (int i = 0; i < N; i++){``           ``System.out.println();``           ``for (int j = 0; j < N; j++)``           ``System.out.print(dp[i][j] + " ");``           ``}``            ``*/``            ` `        ``return` `dp[``0``][N - ``1``];``    ``}` `    ``// Driver code to test above methods``    ``public` `static` `void` `main(String args[]) {``        ``String str = ``"2553432"``;``        ``System.out.println(minStepToDeleteString(str));``    ``}``}``// This code is contributed by Sumit Ghosh`

## Python 3

 `# Python 3 program to find minimum``# step to delete a string` `# method returns minimum step for``# deleting the string, where in one``# step a palindrome is removed``def` `minStepToDeleteString(``str``):` `    ``N ``=` `len``(``str``)` `    ``# declare dp array and initialize``    ``# it with 0s``    ``dp ``=` `[[``0` `for` `x ``in` `range``(N ``+` `1``)]``             ``for` `y ``in` `range``(N ``+` `1``)]` `    ``# loop for substring length``    ``# we are considering``    ``for` `l ``in` `range``(``1``, N ``+` `1``):``        ` `        ``# loop with two variables i and j, denoting``        ``# starting and ending of substrings``        ``i ``=` `0``        ``j ``=` `l ``-` `1``        ``while` `j < N:``        ` `            ``# If substring length is 1,``            ``# then 1 step will be needed``            ``if` `(l ``=``=` `1``):``                ``dp[i][j] ``=` `1``            ``else``:``            ` `                ``# delete the ith char individually``                ``# and assign result for subproblem (i+1,j)``                ``dp[i][j] ``=` `1` `+` `dp[i ``+` `1``][j]` `                ``# if current and next char are``                ``# same, choose min from current``                ``# and subproblem (i+2,j)``                ``if` `(``str``[i] ``=``=` `str``[i ``+` `1``]):``                    ``dp[i][j] ``=` `min``(``1` `+` `dp[i ``+` `2``][j], dp[i][j])` `                ``''' loop over all right characters and suppose``                    ``Kth char is same as ith character then``                    ``choose minimum from current and two``                    ``substring after ignoring ith and Kth char '''``                ``for` `K ``in` `range``(i ``+` `2``, j ``+` `1``):``                    ``if` `(``str``[i] ``=``=` `str``[K]):``                        ``dp[i][j] ``=` `min``(dp[i ``+` `1``][K ``-` `1``] ``+``                                       ``dp[K ``+` `1``][j], dp[i][j])``                        ` `            ``i ``+``=` `1``            ``j ``+``=` `1` `    ``# Uncomment below snippet to print``    ``# actual dp tablex``    ``# for (int i = 0; i < N; i++, cout << endl)``    ``# for (int j = 0; j < N; j++)``    ``#     cout << dp[i][j] << " ";` `    ``return` `dp[``0``][N ``-` `1``]` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``str` `=` `"2553432"``    ``print``( minStepToDeleteString(``str``))` `# This code is contributed by ChitraNayal`

## C#

 `// C# program to find minimum step to``// delete a string``using` `System;` `class` `GFG {   ``    ` `    ``/* method returns minimum step for deleting``    ``the string, where in one step a``    ``palindrome is removed */``    ``static` `int` `minStepToDeleteString(``string` `str)``    ``{``        ``int` `N = str.Length;` `        ``// declare dp array and initialize it``        ``// with 0s``        ``int` `[,]dp = ``new` `int``[N + 1,N + 1];``        ` `        ``for` `(``int` `i = 0; i <= N; i++)``            ``for` `(``int` `j = 0; j <= N; j++)``                ``dp[i,j] = 0;` `        ``// loop for substring length we are``        ``// considering``        ``for` `(``int` `len = 1; len <= N; len++) {``            ` `            ``// loop with two variables i and j,``            ``// denoting starting and ending of``            ``// substrings``            ``for` `(``int` `i = 0, j = len - 1; j < N; i++, j++)``            ``{``    ` `                ``// If substring length is 1, then 1``                ``// step will be needed``                ``if` `(len == 1)``                    ``dp[i,j] = 1;``                    ` `                ``else``                ``{``                    ``// delete the ith char individually``                    ``// and assign result for``                    ``// subproblem (i+1,j)``                    ``dp[i,j] = 1 + dp[i + 1,j];` `                    ``// if current and next char are same,``                    ``// choose min from current and``                    ``// subproblem (i+2, j)``                    ``if` `(str[i] == str[i + 1])``                        ``dp[i,j] = Math.Min(1 + dp[i + 2,j],``                                                  ``dp[i,j]);` `                    ``/* loop over all right characters and``                    ``suppose Kth char is same as ith``                    ``character then choose minimum from``                    ``current and two substring after``                    ``ignoring ith and Kth char``                    ``*/``                    ``for` `(``int` `K = i + 2; K <= j; K++)``                        ``if` `(str[i] == str[K])``                            ``dp[i,j] = Math.Min(``                                        ``dp[i + 1,K - 1] +``                                     ``dp[K + 1,j], dp[i,j]);``                ``}``            ``}``        ``}` `        ``/* Uncomment below snippet to print actual dp tablex``        ` `        ``for (int i = 0; i < N; i++){``        ``System.out.println();``        ``for (int j = 0; j < N; j++)``        ``System.out.print(dp[i][j] + " ");``        ``} */``            ` `        ``return` `dp[0,N - 1];``    ``}` `    ``// Driver code to test above methods``    ``public` `static` `void` `Main()``    ``{``        ``string` `str = ``"2553432"``;``        ``Console.Write(minStepToDeleteString(str));``    ``}``}` `// This code is contributed by nitin mittal`

## PHP

 ``

## Javascript

 ``

Output:

`2`

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