# Minimum palindromic subarray removals to make array Empty

Given an array arr[] consisting of N elements, the task is to find the minimum palindromic subarray removals required to remove all elements from the array.

Examples:

Input: arr[] = {1, 3, 4, 1, 5}, N = 5
Output: 3
Explanation:
Removal of 4 from the array leaves {1, 3, 1, 5}.
Removal of {1, 3, 1} leaves {5}.
Removal of 5 makes the array empty.

Input: arr[] = {1, 2, 3, 5, 3, 1}, N = 5
Output: 2
Explanation:
Removal of {3, 5, 3} leaves {1, 2, 1}.
Removal of {1, 2, 1} makes the array empty.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
We can use Interval Dynamic Programming to solve this problem. Follow the steps below to solve the problem:

• Initialize dp[][] such that every dp[i][j] represents the minimum number of removals required from the ith position to the jth position.
• For the interval from i to j, the answer may be the sum of the two intervals from i to k and k + 1 to j, that is:

dp [i][j]= minimum (dp [i][j], dp [i][k] + dp [k + 1][j]) where i ≤ k <j

• In addition to this possibility, we need to check if arr[i] = arr[j], then dp[i][j] = dp[i + 1][j – 1].
• Below is the implementation of the above approach:

## C++

 `// C++ Program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `int` `dp; ` `int` `minSubarrayRemoval(vector<``int``>& arr) ` `{ ` `    ``int` `i, j, k, l; ` `    ``int` `n = arr.size(); ` ` `  `    ``for` `(i = 0; i < n; i++) { ` `        ``for` `(j = 0; j < n; j++) { ` `            ``dp[i][j] = n; ` `        ``} ` `    ``} ` ` `  `    ``for` `(i = 0; i < n; i++) { ` `        ``dp[i][i] = 1; ` `    ``} ` ` `  `    ``for` `(i = 0; i < n - 1; i++) { ` `        ``if` `(arr[i] == arr[i + 1]) { ` `            ``dp[i][i + 1] = 1; ` `        ``} ` `        ``else` `{ ` `            ``dp[i][i + 1] = 2; ` `        ``} ` `    ``} ` `    ``for` `(l = 2; l < n; l++) { ` `        ``for` `(i = 0; i + l < n; i++) { ` `            ``j = i + l; ` `            ``if` `(arr[i] == arr[j]) { ` `                ``dp[i][j] = dp[i + 1][j - 1]; ` `            ``} ` `            ``for` `(k = i; k < j; k++) { ` `                ``dp[i][j] ` `                    ``= min( ` `                        ``dp[i][j], ` `                        ``dp[i][k] ` `                            ``+ dp[k + 1][j]); ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `dp[n - 1]; ` `} ` `// Driver Program ` `int` `main() ` `{ ` `    ``vector<``int``> arr ` `        ``= { 2, 3, 1, 2, 2, 1, 2 }; ` `    ``int` `ans = minSubarrayRemoval(arr); ` `    ``cout << ans << endl; ` `} `

## Java

 `// Java program for the above approach ` `class` `GFG{  ` `     `  `static` `int` `dp[][] = ``new` `int``[``550``][``550``]; ` ` `  `static` `int` `minSubarrayRemoval(``int` `arr[]) ` `{ ` `    ``int` `i, j, k, l; ` `    ``int` `n = arr.length; ` ` `  `    ``for``(i = ``0``; i < n; i++)  ` `    ``{ ` `       ``for``(j = ``0``; j < n; j++) ` `       ``{ ` `          ``dp[i][j] = n; ` `       ``} ` `    ``} ` ` `  `    ``for``(i = ``0``; i < n; i++) ` `    ``{ ` `       ``dp[i][i] = ``1``; ` `    ``} ` ` `  `    ``for``(i = ``0``; i < n - ``1``; i++) ` `    ``{ ` `       ``if` `(arr[i] == arr[i + ``1``]) ` `       ``{ ` `           ``dp[i][i + ``1``] = ``1``; ` `       ``} ` `       ``else`  `       ``{ ` `           ``dp[i][i + ``1``] = ``2``; ` `       ``} ` `    ``} ` `     `  `    ``for``(l = ``2``; l < n; l++) ` `    ``{ ` `       ``for``(i = ``0``; i + l < n; i++) ` `       ``{ ` `          ``j = i + l; ` `          ``if` `(arr[i] == arr[j]) ` `          ``{ ` `              ``dp[i][j] = dp[i + ``1``][j - ``1``]; ` `          ``} ` `          ``for``(k = i; k < j; k++) ` `          ``{ ` `             ``dp[i][j] = Math.min(dp[i][j],  ` `                                 ``dp[i][k] + ` `                                 ``dp[k + ``1``][j]); ` `          ``} ` `       ``} ` `    ``} ` `    ``return` `dp[``0``][n - ``1``]; ` `} ` `     `  `// Driver code  ` `public` `static` `void` `main (String[] args)  ` `{  ` `    ``int` `arr [] = ``new` `int``[]{ ``2``, ``3``, ``1``, ``2``, ``2``, ``1``, ``2` `}; ` `    ``int` `ans = minSubarrayRemoval(arr); ` `     `  `    ``System.out.println(ans); ` `}  ` `}  ` ` `  `// This code is contributed by Pratima Pandey  `

## Python3

 `# Python3 program for the above approach ` `def` `minSubarrayRemoval(arr): ` `     `  `    ``n ``=` `len``(arr) ` `    ``dp ``=` `[] ` `     `  `    ``for` `i ``in` `range``(n): ` `        ``l ``=` `[``0``] ``*` `n ` `        ``for` `j ``in` `range``(n): ` `            ``l[j] ``=` `n ` `        ``dp.append(l) ` `     `  `    ``for` `i ``in` `range``(n): ` `        ``dp[i][i] ``=` `1` `         `  `    ``for` `i ``in` `range``(n ``-` `1``): ` `        ``if` `(arr[i] ``=``=` `arr[i ``+` `1``]): ` `            ``dp[i][i ``+` `1``] ``=` `1` `        ``else``: ` `            ``dp[i][i ``+` `1``] ``=` `2` `             `  `    ``for` `l ``in` `range``(``2``, n): ` `        ``for` `i ``in` `range``(n ``-` `l): ` `            ``j ``=` `i ``+` `l ` `            ``if` `(arr[i] ``=``=` `arr[j]): ` `                ``dp[i][j] ``=` `dp[i ``+` `1``][j ``-` `1``] ` `             `  `            ``for` `k ``in` `range``(i, j): ` `                ``dp[i][j] ``=` `min``(dp[i][j],  ` `                               ``dp[i][k] ``+`  `                               ``dp[k ``+` `1``][j]) ` `     `  `    ``return` `dp[``0``][n ``-` `1``] ` ` `  `# Driver code ` `arr ``=` `[ ``2``, ``3``, ``1``, ``2``, ``2``, ``1``, ``2` `] ` `ans ``=` `minSubarrayRemoval(arr) ` ` `  `print``(ans) ` ` `  `# This code is contributed by shubhamsingh10 `

## C#

 `// C# program for the above approach ` `using` `System; ` `class` `GFG{  ` `     `  `static` `int` `[,]dp = ``new` `int``[550, 550]; ` ` `  `static` `int` `minSubarrayRemoval(``int` `[]arr) ` `{ ` `    ``int` `i, j, k, l; ` `    ``int` `n = arr.Length; ` ` `  `    ``for``(i = 0; i < n; i++)  ` `    ``{ ` `       ``for``(j = 0; j < n; j++) ` `       ``{ ` `          ``dp[i, j] = n; ` `       ``} ` `    ``} ` ` `  `    ``for``(i = 0; i < n; i++) ` `    ``{ ` `       ``dp[i, i] = 1; ` `    ``} ` ` `  `    ``for``(i = 0; i < n - 1; i++) ` `    ``{ ` `       ``if` `(arr[i] == arr[i + 1]) ` `       ``{ ` `           ``dp[i, i + 1] = 1; ` `       ``} ` `       ``else` `       ``{ ` `           ``dp[i, i + 1] = 2; ` `       ``} ` `    ``} ` `     `  `    ``for``(l = 2; l < n; l++) ` `    ``{ ` `       ``for``(i = 0; i + l < n; i++) ` `       ``{ ` `          ``j = i + l; ` `          ``if` `(arr[i] == arr[j]) ` `          ``{ ` `              ``dp[i, j] = dp[i + 1, j - 1]; ` `          ``} ` `          ``for``(k = i; k < j; k++) ` `          ``{ ` `             ``dp[i, j] = Math.Min(dp[i, j],  ` `                                 ``dp[i, k] + ` `                                 ``dp[k + 1, j]); ` `          ``} ` `       ``} ` `    ``} ` `    ``return` `dp[0, n - 1]; ` `} ` `     `  `// Driver code  ` `public` `static` `void` `Main()  ` `{  ` `    ``int` `[]arr = ``new` `int``[]{ 2, 3, 1, 2, 2, 1, 2 }; ` `    ``int` `ans = minSubarrayRemoval(arr); ` `     `  `    ``Console.Write(ans); ` `}  ` `}  ` ` `  `// This code is contributed by Code_Mech `

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.