Minimum Insertion To Form A Palindrome in Java

A string is given to us. Our task is to convert that string into a palindromic string by inserting characters. The characters should be inserted only on the leftmost side of the input string. In the output, we have to mention the total number of characters that are being inserted in the input string to make it a palindrome string. See the following mentioned examples.

Example: 1

Input:

String str = "ab"

Output: 1

Explanation: If we insert the character 'b' in the leftmost side of the string, we get the string, "bab", which is a palindrome. Thus, the total number of inserted characters in the input string is 1.

Example: 2

Input:

String str = "abcd"

Output: 3

Explanation: If we insert the character 'b' in the leftmost side of the string we get the string, "dcbabcd", which is a palindrome. Thus, the total number of inserted characters in the input string is 3.

Example: 3

Input:

String str = "bab"

Output: 0

Explanation: The input string is already a palindrome string. Hence, no insertion of characters is required. Hence, the output is 0.

Naïve Approach

In this approach, we will be using recursion. We will be using a method computeMinInsertions() that computes the minimum count of characters for making a palindromic string. Observe the following implementation.

FileName: MinInsertionPalindrome.java

public class MinInsertionPalindrome 
{

// Recursive method that computes the minimum number
// of characters insertion to make the string inputStr a palindrome 
public int computeMinInsertions(char inputStr[], int s, int e)
{
// Handling the Base Cases
if (s > e) 
{
return Integer.MAX_VALUE;
}
if (s == e) 
{
// the input string only contains one character
return 0;
}
if (s == e - 1) 
{
// the input string only contains two characters
// if both the characters are the same, the string is a palindrome.
// Otherwise, we need to add one more character at the beginning of
// the input string.
return (inputStr[s] == inputStr[e]) ? 0 : 1;
}

// Checking whether the first and the last characters
// are the same or not. The comparison result decides which 
// subproblems we need to solve.

if(inputStr[s] == inputStr[e]) 
{
// the first and the last characters match. Hence, we exclude the 
// first and the last characters and apply the recursion on the 
// rest of the characters of the string
return computeMinInsertions(inputStr, s + 1, e - 1);
}
else
{
// computing minimum of the two subproblems: one subproblem is excluding the first character, and 
// other subproblem is excluding the last character.
return (Integer.min(computeMinInsertions(inputStr, s, e - 1), computeMinInsertions(inputStr, s + 1, e)) + 1);
}
}

// Main Method
public static void main(String argvs[])
{
// creating an object of the class MinInsertionPalindrome
MinInsertionPalindrome obj = new MinInsertionPalindrome();

// input 1
String inputStr= "ab";
int ans = obj.computeMinInsertions(inputStr.toCharArray(), 0, inputStr.length() - 1);
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();

// input 2
inputStr= "abcd";
ans = obj.computeMinInsertions(inputStr.toCharArray(), 0, inputStr.length() - 1);
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();

// input 3
inputStr= "bab";
ans = obj.computeMinInsertions(inputStr.toCharArray(), 0, inputStr.length() - 1);
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();
}
}

Output:

For the string: ab
The minimum number of characters that should be inserted to make it palindromic is: 1

For the string: abcd
The minimum number of characters that should be inserted to make it palindromic is: 3

For the string: bab
The minimum number of characters that should be inserted to make it palindromic is: 0

Complexity Analysis: The time complexity of the program is O(nⁿ), and the space complexity of the program is O(n), where n is the total number of characters present in the input string.

The time complexity of the above program is very high and is not suitable for large inputs. The reason for the high time complexity is due to many sub-problems getting computed again and again. We can avoid the repeated computation of the sub-problems with the help of dynamic programming. The following approach shows the same.

Approach: Using Dynamic Programming

We will be using a 2-Dimensional array to store the solution of the sub-problems so that they are not computed again and again. Also, we will use the stored sub-problem solution to compute the final solution.

FileName: MinInsertionPalindrome1.java

public class MinInsertionPalindrome1  
{

// Recursive method that computes the minimum number
// of characters insertion to make the string inputStr a palindrome 
public int computeMinInsertions(char inputStr[], int len)
{
// Creating a (len x len) sized table. dp[p][q]
// stores the minimum number of insertions that are 
// required for converting the string[p ... q] into a palindrome
int dp[][] = new int[len][len];
int l, h, gap;

// Filling the dp table
for (int gp = 1; gp < len; gp++)
{
for (l = 0, h = gp; h < len; l++, h++)
{
dp[l][h] = (inputStr[l] == inputStr[h]) ? dp[l + 1][h - 1] : (Integer.min(dp[l][h - 1], dp[l + 1][h]) + 1);
}
}

// Returning the minimum number of insertions
// for the str[0 ... len - 1]
return dp[0][len - 1];
}

// Main Method
public static void main(String argvs[])
{
// creating an object of the class MinInsertionPalindrome1
MinInsertionPalindrome1 obj = new MinInsertionPalindrome1();

// input 1
String inputStr= "ab";
int ans = obj.computeMinInsertions(inputStr.toCharArray(), inputStr.length());
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();

// input 2
inputStr= "abcd";
ans = obj.computeMinInsertions(inputStr.toCharArray(), inputStr.length());
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();

// input 3
inputStr= "bab";
ans = obj.computeMinInsertions(inputStr.toCharArray(), inputStr.length());
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();
}
}

Output:

For the string: ab
The minimum number of characters that should be inserted to make it palindromic is: 1

For the string: abcd
The minimum number of characters that should be inserted to make it palindromic is: 3

For the string: bab
The minimum number of characters that should be inserted to make it palindromic is: 0

Complexity Analysis: Since two loops are used (nested loops) in the program, the total time complexity of the program is O(n²). Also, a 2-dimensional array is used in the method computeMinInsertions(), making the space complexity of the program O(n²), where n is the total number of characters present in the input string.

Another Approach: Using Longest Common Subsequence

Another approach is to use the concept of the LCS (Longest Common Subsequence) problem. Using this approach, we will find the LCS of the input string and the reverse of the input string.

FileName: MinInsertionPalindrome2.java

public class MinInsertionPalindrome2  
{

public int findLCS( String st1, String st2, int siz1, int siz2)
{
int LCS[][] = new int[siz1 + 1][siz2 + 1];
int p, q;

// Following are the steps used to fill LCS[siz1 + 1][siz2 + 1] in
// the bottom-up fashion. Note that LCS[p][q]
// contains length of LCS of st1[0 ... p - 1]
// and st2[0 ... q - 1] 
for (p = 0; p <= siz1; p++)
{
for (q = 0; q <= siz2; q++)
{
if (p == 0 || q == 0)
{
LCS[p][q] = 0;
}

else if (st1.charAt(p - 1) == st2.charAt(q - 1))
{
LCS[p][q] = LCS[p - 1][q - 1] + 1;
}

else
{
LCS[p][q] = Integer.max(LCS[p - 1][q], LCS[p][q - 1]);
}
}
}

// LCS[siz1][siz2] keeps the length of the LCS for
//   st1[0 ...  siz1 - 1] and st2[0 ... siz2 - 1] 
return LCS[siz1][siz2];
}

// A method that computes the minimum number
// of characters insertion to make the string inputStr a palindrome 
public int computeMinInsertions(String inputStr, int len)
{
// Using StringBuffer to reverse a String
StringBuffer strBufObj = new StringBuffer(inputStr);
strBufObj.reverse();
String reverseString = strBufObj.toString();

// The result is the length of the input string minus
// the length of the LCS of the input string and its reverse

int res = len - findLCS(inputStr, reverseString , len, len);
return res;
}

// Main Method
public static void main(String argvs[])
{
// creating an object of the class MinInsertionPalindrome2
MinInsertionPalindrome2 obj = new MinInsertionPalindrome2();

// input 1
String inputStr= "ab";
int ans = obj.computeMinInsertions(inputStr, inputStr.length());
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();

// input 2
inputStr= "abcd";
ans = obj.computeMinInsertions(inputStr, inputStr.length());
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();

// input 3
inputStr= "bab";
ans = obj.computeMinInsertions(inputStr, inputStr.length());
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();
}
}

Output:

For the string: ab
The minimum number of characters that should be inserted to make it palindromic is: 1

For the string: abcd
The minimum number of characters that should be inserted to make it palindromic is: 3

For the string: bab
The minimum number of characters that should be inserted to make it palindromic is: 0

Complexity Analysis: The time, as well as space complexity of the program is the same as the previous program.

We can still do optimization in terms of space complexity. Note that in the lcs table, we only need the current row and the previous row elements. The illustration of the same is given in the following program.

FileName: MinInsertionPalindrome3.java

public class MinInsertionPalindrome3  
{

public int findLCS( String st1, String st2, int siz1, int siz2)
{
// for storing the values of the last computed elements
int prvArr[] = new int[siz1 + 1];

// for storing the values of the currently computed elements
int currArr[] = new int[siz2 + 1];

int p, q;

for (p = 0; p <= siz1; p++)
{
for (q = 0; q <= siz2; q++)
{
// handling the base case
if (p == 0 || q == 0)
{
prvArr[q] = 0;
}

// if the first element of the input string and its reverse are the same
// then increment the value of the currArr[q] by 1
else if (st1.charAt(p - 1) == st2.charAt(q - 1))
{
currArr[q] = prvArr[q - 1] + 1;
}

else
{
currArr[q] = Math.max(prvArr[q], currArr[q - 1]);
}
}

for (int p1 = 0; p1 <= siz1; p1++)
{
prvArr[p1] = currArr[p1];
}

}

// LCS[siz1][siz2] keeps the length of the LCS for
//   st1[0 ...  siz1 - 1] and st2[0 ... siz2 - 1] 
return prvArr[siz1];
}

// A method that computes the minimum number
// of characters insertion to make the string inputStr a palindrome 
public int computeMinInsertions(String inputStr, int len)
{
// Using StringBuffer to reverse a String
StringBuffer strBufObj = new StringBuffer(inputStr);
strBufObj.reverse();
String reverseString = strBufObj.toString();

// The result is the length of the input string minus
// the length of the LCS of the input string and its reverse

int res = len - findLCS(inputStr, reverseString , len, len);
return res;
}

// Main Method
public static void main(String argvs[])
{
// creating an object of the class MinInsertionPalindrome3
MinInsertionPalindrome3 obj = new MinInsertionPalindrome3();

// input 1
String inputStr= "ab";
int ans = obj.computeMinInsertions(inputStr, inputStr.length());
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans);
System.out.println();

// input 2
inputStr= "abcd";
ans = obj.computeMinInsertions(inputStr, inputStr.length());
System.out.println("For the string: " + inputStr);
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans );
System.out.println();

// input 3
inputStr= "bab";
ans = obj.computeMinInsertions(inputStr, inputStr.length());
System.out.println("For the string: " + inputStr );
System.out.println("The minimum number of characters that should be inserted to make it palindromic is: " + ans );
System.out.println();
}
}

Output:

For the string: ab
The minimum number of characters that should be inserted to make it palindromic is: 1

For the string: abcd
The minimum number of characters that should be inserted to make it palindromic is: 3

For the string: bab
The minimum number of characters that should be inserted to make it palindromic is: 0

Complexity Analysis: The time complexity of the program is the same as the previous program. However, the space complexity of the program is better than the previous one, which is O(N), where N is the total number of characters present in the input string. It is because the program is only using single-dimensional arrays.

Next TopicWiggle Sort in Java

← prev next →