Minimum Insertion Steps to Make a String Palindrome

Minimum Insertion Steps to Make a String Palindrome - Problem

Imagine you have a string that's almost a palindrome, but not quite there yet. Your mission? Transform it into a perfect palindrome by strategically inserting characters!

Given a string s, you can insert any character at any position in the string. Your goal is to find the minimum number of insertions needed to make the string read the same forwards and backwards.

What makes this challenging? You need to be smart about which characters to insert and where to place them. For example:

"zzazz" is already a palindrome → 0 insertions needed
"mbadm" can become "mbdadbm" → 2 insertions needed
"leetcode" requires more strategic planning → 5 insertions needed

This problem tests your understanding of dynamic programming and string manipulation, making it a favorite in technical interviews!

Input & Output

example_1.py — Basic Case

$ Input: s = "zzazz"

› Output: 0

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

example_2.py — Simple Transformation

$ Input: s = "mbadm"

› Output: 2

💡 Note: We can transform "mbadm" to "mbdadbm" by inserting 'd' after 'b' and 'b' before the last 'm'. This creates a palindrome with just 2 insertions.

example_3.py — Complex Case

$ Input: s = "leetcode"

› Output: 5

💡 Note: One way is to transform "leetcode" to "etelcecotele" by strategically inserting 5 characters to make it palindromic.

Constraints

1 ≤ s.length ≤ 500
s consists of lowercase English letters only
Time limit: 1 second per test case

Visualization

Tap to expand

Understanding the Visualization

Identify Mismatches

Find positions where characters don't mirror each other

Strategic Insertion

Insert characters to create perfect symmetry

Minimize Operations

Use DP to find the minimum number of insertions needed

Key Takeaway

🎯 Key Insight: This problem is equivalent to finding the Longest Palindromic Subsequence (LPS). The minimum insertions needed equals string length minus LPS length, solved efficiently using dynamic programming.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses dynamic programming with O(n²) time complexity. We build a 2D table where each cell represents the minimum insertions needed for a substring. The key insight is that this problem is equivalent to finding the Longest Palindromic Subsequence - the answer equals string length minus LPS length. For each substring, if the end characters match, we inherit the result from the inner substring; otherwise, we take the minimum of two possibilities plus one insertion.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (2D Table)	O(n²)	O(n²)	Build a 2D DP table to store minimum insertions for all substrings

Dynamic Programming (2D Table) — Algorithm Steps

Create a 2D DP table of size n×n initialized with zeros
Fill diagonal (single characters need 0 insertions)
For each substring length from 2 to n, fill the table
If characters match: dp[i][j] = dp[i+1][j-1]
If characters don't match: dp[i][j] = 1 + min(dp[i+1][j], dp[i][j-1])
Return dp[0][n-1] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create n×n table, diagonal is 0 (single chars)

Fill by Length

Process substrings by increasing length

Character Match

If s[i]==s[j], copy diagonal value

Character Mismatch

Take minimum of adjacent cells plus 1

Code -

solution.c — C

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

int minInsertions(char* s) {
    int n = strlen(s);
    if (n <= 1) return 0;
    
    // Create DP table
    int** dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Fill the table for all substring lengths
    for (int length = 2; 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 {
                int option1 = dp[i + 1][j];
                int option2 = dp[i][j - 1];
                dp[i][j] = 1 + (option1 < option2 ? option1 : option2);
            }
        }
    }
    
    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);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    printf("%d\n", minInsertions(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We fill an n×n table, each cell takes constant time to compute

⚠ Quadratic Growth

Space Complexity

O(n²)

The 2D DP table requires n×n space to store all subproblem results

⚠ Quadratic Space

42.0K Views

Medium-High Frequency

~18 min Avg. Time

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

Dynamic Programming (2D Table) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler