Minimum Insertion Steps to Make a String Palindrome

Minimum Insertion Steps to Make a String Palindrome - Problem

Given a string s. In one step you can insert any character at any index of the string.

Return the minimum number of steps to make s palindrome.

A Palindrome String is one that reads the same backward as well as forward.

Input & Output

Example 1 — Basic Case

$ Input: s = "zzazz"

› Output: 2

💡 Note: Insert 'z' at index 2 and 'a' at index 6 to get "zzzazzz" which is palindromic. We can also insert 'a' at index 1 and 'a' at index 3 to get "zaaazz", but that's not optimal.

Example 2 — Already Palindrome

$ Input: s = "racecar"

› Output: 0

💡 Note: The string is already a palindrome, so no insertions are needed.

Example 3 — Single Character

$ Input: s = "a"

› Output: 0

💡 Note: Single character is always a palindrome.

Constraints

1 ≤ s.length ≤ 500
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is that minimum insertions equals string length minus the longest palindromic subsequence. Best approach uses 2D Dynamic Programming to find LPS efficiently. Time: O(n²), Space: O(n²)

Common Approaches

✓ 2D Dynamic Programming

⏱️ Time: O(n²) Space: O(n²)

Use a 2D table where dp[i][j] represents minimum insertions needed to make substring from index i to j a palindrome. Fill the table bottom-up from smaller to larger substrings.

Brute Force

⏱️ Time: O(26^n) Space: O(n)

For each position, try inserting each possible character and recursively solve for the remaining string. This explores all possible ways to make the string a palindrome.

Longest Palindromic Subsequence

⏱️ Time: O(n²) Space: O(n²)

Key insight: minimum insertions = n - length of longest palindromic subsequence. We can find LPS using DP by comparing string with its reverse and finding longest common subsequence.

Memoization (Top-Down DP)

⏱️ Time: O(n²) Space: O(n²)

Convert the brute force approach to use memoization by caching results of subproblems. We recursively compare characters from both ends and memoize the minimum insertions needed.

2D Dynamic Programming — Algorithm Steps

Create 2D DP table
Fill base cases (single characters and empty strings)
For each substring, compare end characters
If match, take diagonal value; if not, take minimum of adjacent cells + 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create n×n table for all substring combinations

Fill Base Cases

Single chars need 0 insertions, pairs need 0 or 1

Build Up

For larger substrings, use previously computed values

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(char* s) {
    int n = strlen(s);
    if (n <= 1) return 0;
    
    // dp[i][j] = min insertions to make s[i..j] palindrome
    int** dp = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = calloc(n, sizeof(int));
    }
    
    // Fill for length 2 substrings
    for (int i = 0; i < n - 1; i++) {
        if (s[i] != s[i + 1]) {
            dp[i][i + 1] = 1;
        }
    }
    
    // Fill for length 3 and above
    for (int length = 3; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            if (s[i] == s[j]) {
                dp[i][j] = dp[i + 1][j - 1];
            } else {
                dp[i][j] = 1 + min(dp[i + 1][j], dp[i][j - 1]);
            }
        }
    }
    
    int result = dp[0][n - 1];
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops iterate through all n² possible substrings

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table of size n×n stores results for all substrings

⚠ Quadratic Space

89.6K Views

Medium Frequency

~25 min Avg. Time

2.8K 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

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler