C Program To Find Minimum Insertions To Form A Palindrome | DP-28

Last Updated : 14 May, 2023

Given string str, the task is to find the minimum number of characters to be inserted to convert it to a palindrome.

Before we go further, let us understand with a few examples:

ab: Number of insertions required is 1 i.e. bab
aa: Number of insertions required is 0 i.e. aa
abcd: Number of insertions required is 3 i.e. dcbabcd
abcda: Number of insertions required is 2 i.e. adcbcda which is the same as the number of insertions in the substring bcd(Why?).
abcde: Number of insertions required is 4 i.e. edcbabcde

Let the input string be str[l……h]. The problem can be broken down into three parts:

Find the minimum number of insertions in the substring str[l+1,…….h].
Find the minimum number of insertions in the substring str[l…….h-1].
Find the minimum number of insertions in the substring str[l+1……h-1].

Recursive Approach: The minimum number of insertions in the string str[l…..h] can be given as:

minInsertions(str[l+1…..h-1]) if str[l] is equal to str[h]
min(minInsertions(str[l…..h-1]), minInsertions(str[l+1…..h])) + 1 otherwise

Below is the implementation of the above approach:

// A Naive recursive program to find minimum  // number insertions needed to make a string // palindrome #include <stdio.h> #include <limits.h> #include <string.h>  // A utility function to find minimum of  // two numbers int min(int a, int b) {  return a < b ? a : b; }  // Recursive function to find minimum number  // of insertions int findMinInsertions(char str[],                        int l, int h) {     // Base Cases     if (l > h)          return INT_MAX;      if (l == h)          return 0;      if (l == h - 1)          return ((str[l] == str[h]) ?                   0 : 1);      // Check if the first and last characters      // are same. On the basis of the comparison      // result, decide which subproblem(s) to call     return (str[l] == str[h])?              findMinInsertions(str, l + 1, h - 1):             (min(findMinInsertions(str, l, h - 1),              findMinInsertions(str, l + 1, h)) + 1); }  // Driver code int main() {     char str[] = "geeks";     printf("%d",      findMinInsertions(str, 0,                        strlen(str)-1));     return 0; }

Output

Memoisation based appraoch(Dynamic Programming):

If we observe the above approach carefully, we can find that it exhibits overlapping subproblems.
Suppose we want to find the minimum number of insertions in string "abcde":

                      abcde             /       |                  /        |                    bcde         abcd       bcd  <- case 3 is discarded as str[l] != str[h]        /   |          /   |          /    |         /    |          cde   bcd  cd   bcd abc bc    / |   / |  /| / |  de cd d cd bc c………………….

The substrings in bold show that the recursion is to be terminated and the recursion tree cannot originate from there. Substring in the same color indicates overlapping subproblems.

This gave rise to use dynamic programming approach to store the results of subproblems which can be used later. In this apporach we will go with memoised version and in the next one with tabulation version.

Algorithm:

Define a function named findMinInsertions which takes a character array str, a two-dimensional vector dp, an integer l and an integer h as arguments.
If l is greater than h, then return INT_MAX as this is an invalid case.
If l is equal to h, then return 0 as no insertions are needed.
If l is equal to h-1, then check if the characters at index l and h are same. If yes, then return 0 else return 1. Store the result in the dp[l][h] matrix.
If the value of dp[l][h] is not equal to -1, then return the stored value.
Check if the first and last characters of the string str are same. If yes, then call the function findMinInsertions recursively by passing arguments str, dp, l+1, and h-1.
If the first and last characters of the string str are not same, then call the function findMinInsertions recursively by passing arguments str, dp, l, and h-1 and also call the function recursively by passing arguments str, dp, l+1, and h. The minimum of the two calls is the answer. Add 1 to it, as one insertion is required to make the string palindrome. Store this result in the dp[l][h] matrix.
Return the result stored in the dp[l][h] matrix.

Below is the implementation of the approach:

C++

// C++ program to find minimum // number insertions needed to make a string // palindrome  #include <bits/stdc++.h>  using namespace std;  // A utility function to find minimum of // two numbers int min(int a, int b) { return a < b ? a : b; }  // Function to find minimum number // of insertions int findMinInsertions(char str[], vector<vector<int>> &dp,                     int l, int h) {     // Base Cases     if (l > h)         return INT_MAX;      if (l == h)         return 0;      if (l == h - 1)         return dp[l][h] = ((str[l] == str[h]) ?                 0 : 1);        if( dp[l][h] != -1 )           return dp[l][h];        // Check if the first and last characters     // are same. On the basis of the comparison     // result, decide which subproblem(s) to call     return dp[l][h] = (str[l] == str[h])?             findMinInsertions(str, dp, l + 1, h - 1):             (min(findMinInsertions(str, dp, l, h - 1),             findMinInsertions(str, dp, l + 1, h)) + 1); }  // Driver code int main() {     char str[] = "geeks";     int n = strlen(str);          // initialise dp vector      vector<vector<int>> dp(n, vector<int>(n, -1));        printf("%d",     findMinInsertions(str, dp, 0,                     strlen(str)-1));     return 0; }  // This code is contributed by Chandramani Kumar

Output

Time complexity: O(N^2) where N is size of input string.
Auxiliary Space: O(N^2) as 2d dp array has been created to store the states. Here N is size of input string.

Dynamic Programming based Solution:
If we observe the above approach carefully, we can find that it exhibits overlapping subproblems.
Suppose we want to find the minimum number of insertions in string "abcde":

                      abcde             /       |                  /        |                    bcde         abcd       bcd  <- case 3 is discarded as str[l] != str[h]        /   |          /   |          /    |         /    |          cde   bcd  cd   bcd abc bc    / |   / |  /| / |  de cd d cd bc c………………….

The substrings in bold show that the recursion is to be terminated and the recursion tree cannot originate from there. Substring in the same color indicates overlapping subproblems.

How to re-use solutions of subproblems? The memorization technique is used to avoid similar subproblem recalls. We can create a table to store the results of subproblems so that they can be used directly if the same subproblem is encountered again.
The below table represents the stored values for the string abcde.

a b c d e ---------- 0 1 2 3 4 0 0 1 2 3  0 0 0 1 2  0 0 0 0 1  0 0 0 0 0

How to fill the table?
The table should be filled in a diagonal fashion. For the string abcde, 0….4, the following should be ordered in which the table is filled:

Gap = 1: (0, 1) (1, 2) (2, 3) (3, 4)  Gap = 2: (0, 2) (1, 3) (2, 4)  Gap = 3: (0, 3) (1, 4)  Gap = 4: (0, 4)

Below is the implementation of the above approach:

// A Dynamic Programming based program to find // minimum number insertions needed to make a // string palindrome #include <stdio.h> #include <string.h>  // A utility function to find minimum of  // two integers int min(int a, int b) {   return a < b ? a : b;  }  // A DP function to find minimum number  // of insertions int findMinInsertionsDP(char str[], int n) {     // Create a table of size n*n. table[i][j]     // will store minimum number of insertions      // needed to convert str[i..j] to a palindrome.     int table[n][n], l, h, gap;      // Initialize all table entries as 0     memset(table, 0, sizeof(table));      // Fill the table     for (gap = 1; gap < n; ++gap)         for (l = 0, h = gap; h < n; ++l, ++h)             table[l][h] = (str[l] == str[h])?                            table[l + 1][h - 1] :                           (min(table[l][h - 1],                             table[l + 1][h]) + 1);      // Return minimum number of insertions      // for str[0..n-1]     return table[0][n-1]; }  // Driver code int main() {     char str[] = "geeks";     printf("%d",      findMinInsertionsDP(str,                          strlen(str)));     return 0; }

Output

Time complexity: O(N^2)
Auxiliary Space: O(N^2)

Another Dynamic Programming Solution (Variation of Longest Common Subsequence Problem)
The problem of finding minimum insertions can also be solved using Longest Common Subsequence (LCS) Problem. If we find out the LCS of string and its reverse, we know how many maximum characters can form a palindrome. We need to insert the remaining characters. Following are the steps.

Find the length of LCS of the input string and its reverse. Let the length be 'l'.
The minimum number of insertions needed is the length of the input string minus 'l'.

Below is the implementation of the above approach:

// An LCS based program to find minimum number // insertions needed to make a string palindrome #include<stdio.h> #include <string.h>  // Utility function to get max of 2 integers  int max(int a, int b) {   return (a > b)? a : b; }  /* Returns length of LCS for X[0..m-1], Y[0..n-1].     See http://goo.gl/bHQVP for details of this     function */ int lcs( char *X, char *Y, int m, int n ) {    int L[m+1][n+1];    int i, j;     /* Following steps build L[m+1][n+1] in bottom        up fashion. Note that L[i][j] contains length       of LCS of X[0..i-1] and Y[0..j-1] */    for (i=0; i<=m; i++)    {      for (j=0; j<=n; j++)      {        if (i == 0 || j == 0)          L[i][j] = 0;         else if (X[i-1] == Y[j-1])          L[i][j] = L[i-1][j-1] + 1;         else          L[i][j] = max(L[i-1][j], L[i][j-1]);      }    }     /* L[m][n] contains length of LCS for        X[0..n-1] and Y[0..m-1] */    return L[m][n]; }  // LCS based function to find minimum number  // of insertions int findMinInsertionsLCS(char str[], int n) {    // Create another string to store reverse     // of 'str'    char rev[n+1];    strcpy(rev, str);    strrev(rev);     // The output is length of string minus length     // of lcs of str and it reverse    return (n - lcs(str, rev, n, n)); }  // Driver code int main() {     char str[] = "geeks";     printf("%d",      findMinInsertionsLCS(str,                           strlen(str)));     return 0; }

Output:

Time complexity: O(N^2)
Auxiliary Space: O(N^2)

Please refer complete article on Minimum insertions to form a palindrome | DP-28 for more details!

C Program for Longest Palindromic Subsequence | DP-12

kartik

Improve

Article Tags :

Practice Tags :

C Program To Find Minimum Insertions To Form A Palindrome | DP-28

Similar Reads