Palindrome Removal - Practice Coding Problems

Palindrome Removal - Problem

Imagine you're cleaning up a messy array by removing palindromic sections piece by piece! 🧹

You are given an integer array arr. In one move, you can select any palindromic subarray arr[i], arr[i + 1], ..., arr[j] where i <= j, and completely remove that subarray from the array. After removal, the remaining elements automatically shift together to fill the gap.

A palindromic subarray reads the same forwards and backwards. For example: [1], [2,2], [3,1,3], or [4,5,4].

Goal: Return the minimum number of moves needed to remove all elements from the array.

Example: For array [1,3,4,1,5], you could remove [4] first (1 move), then [3] (1 move), then [1,5,1] is not palindromic, so remove each [1] and [5] separately (2 more moves) = 4 total moves. But there might be a better strategy!

Input & Output

example_1.py — Basic Case

$ Input: [1,3,4,1,5]

› Output: 3

💡 Note: Remove [4] (1 move), then [1,3,1] which becomes palindromic after adjacent elements merge (1 move), then [5] (1 move). Total: 3 moves.

example_2.py — All Same Elements

$ Input: [1,1,1,1]

› Output: 1

💡 Note: The entire array is palindromic, so we can remove it all in just 1 move.

example_3.py — No Palindromes

$ Input: [1,2,3,4]

› Output: 4

💡 Note: No palindromic subarrays of length > 1 exist, so we must remove each element individually. Total: 4 moves.

Constraints

1 ≤ arr.length ≤ 100
1 ≤ arr[i] ≤ 20
Each element is a positive integer
Array is not empty

Visualization

Tap to expand

Move 1: Remove palindrome [4] → [1,3,1,5]Move 2: Remove palindrome [1,3,1] → [5]Move 3: Remove palindrome [5] → []Total: 3 moves (optimal!)🎯 Key InsightDP finds the optimal way to split intervals: either remove as palindrome or split optimally!

Understanding the Visualization

Identify Palindromes

Mark all palindromic subarrays in the input

Build DP Table

Fill table for increasing interval lengths

Choose Strategy

For each interval: remove entirely or split optimally

Get Result

dp[0][n-1] contains minimum moves for entire array

Key Takeaway

🎯 Key Insight: Use interval DP where each subproblem decides whether to remove a palindromic section entirely or split it optimally at some point k.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses Interval Dynamic Programming with O(n³) time complexity. The key insight is that for any interval [i,j], we either remove it as one palindrome (if possible) or find the optimal split point k that minimizes dp[i][k] + dp[k+1][j]. Preprocessing palindrome checks in O(n²) time makes the solution efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Interval Dynamic Programming (Optimal)	O(n³)	O(n²)	Use DP on intervals to find optimal subarray splits
Recursive Brute Force	O(3^n)	O(n^2)	Try all possible palindromic subarray removals recursively

Interval Dynamic Programming (Optimal) — Algorithm Steps

Create DP table where dp[i][j] = min moves for interval [i,j]
For each interval length from 1 to n
For each starting position i, calculate ending position j
If arr[i:j+1] is palindrome, dp[i][j] = 1
Otherwise, try all split points k: dp[i][j] = min(dp[i][k] + dp[k+1][j])

Visualization

Tap to expand

Base case: Single elements (diagonal) = 1 move each2. Palindrome check: If isPal[i][j] = true, then dp[i][j] = 13. Optimal split: Otherwise, dp[i][j] = min(dp[i][k] + dp[k+1][j]) for all k4. Build up: Fill table by increasing interval length5. Result: dp[0][n-1] gives minimum moves for entire arrayTime: O(n³) | Space: O(n²)

Step-by-Step Walkthrough

Palindrome Preprocessing

Mark all palindromic subarrays in isPal table

Length 1 Intervals

Single elements require 1 move each

Length 2+ Intervals

Either 1 move if palindrome, or optimal split

Final Result

dp[0][n-1] gives minimum moves for entire array

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int minimumMoves(int* arr, int n) {
    if (n == 0) return 0;
    
    // Precompute palindromes
    int isPal[20][20];
    memset(isPal, 0, sizeof(isPal));
    
    // Single characters
    for (int i = 0; i < n; i++) {
        isPal[i][i] = 1;
    }
    
    // Length 2
    for (int i = 0; i < n - 1; i++) {
        isPal[i][i + 1] = (arr[i] == arr[i + 1]);
    }
    
    // Length > 2
    for (int length = 3; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            isPal[i][j] = (arr[i] == arr[j]) && isPal[i + 1][j - 1];
        }
    }
    
    // DP table
    int dp[20][20];
    memset(dp, 0, sizeof(dp));
    
    for (int length = 1; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            
            if (isPal[i][j]) {
                dp[i][j] = 1;
            } else {
                dp[i][j] = INT_MAX;
                for (int k = i; k < j; k++) {
                    if (dp[i][k] + dp[k + 1][j] < dp[i][j]) {
                        dp[i][j] = dp[i][k] + dp[k + 1][j];
                    }
                }
            }
        }
    }
    
    return dp[0][n - 1];
}

int main() {
    int arr[20];
    int n = 0;
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[],\n ");
    while (token != NULL && n < 20) {
        arr[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", minimumMoves(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) intervals × O(n) split points or palindrome check

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table storing results for all intervals

⚠ Quadratic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

1.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Interval Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler