Palindrome Partitioning Problem in Java

The palindrome partitioning of a string means dividing the given string in such a way that each substring formed from the given string is a palindrome in itself. In the palindrome partitioning problem in Java, we return the minimum of cuts required to make each of the substrings of the given string palindrome. Let's understand with the help of a few examples.

Example 1:

String str = "pmptuiutpmp"

Minimum number of cuts = 0

It is because the given string is a palindrome. Hence, no cut is required.

Example 2:

String str = "pmpmmmpmmpmpmp"

Minimum number of cuts = 3

With the 3 cuts, we can split the given string into 4 substrings such that each substring is a palindrome. Those 3 cuts are mentioned below.

pmp | m | mmpmm | pmpmp

We see that substrings "pmp", "m", "mmpmm", and "pmpmp" are palindrome.

Example 3:

String str = "pqrstu"

Minimum number of cuts = 5

With the 5 cuts, we can split the given string into 6 substrings such that each substring is a palindrome. Those 5 cuts are mentioned below.

p | q | r | s | t | u

We see that substrings "p", "q", "r", "s", "t", and "u" are palindrome.

There are mainly two approaches to solve this problem: one is the recursive approach, and the other is the iterative approach. Let's start with the recursive approach first.

Using Recursion

Let's see the implementation of the recursive approach.

FileName: PalinPartition.java

public class PalinPartition 
{

// a method for checking whether the string str is palindrome or not
public boolean isPalindrome(String str, int x, int y)
{
while(x < y)
{
if(str.charAt(x) != str.charAt(y))
{
return false; 
}
x = x + 1;
y = y - 1;
}

return true;
}

public int minPalPartition(String str, int x, int y)
{   
// if the string contain only one element or the 
// string is palindrome then there is not cut required
// hence, the number of minimum cut is zero
if( x >= y || isPalindrome(str, x, y) )
{
return 0;
}

// for storing the number of minimum cut
int answer = Integer.MAX_VALUE;
int count;

// for each value m we place a cut and then 
// we try to minimize the number of cuts applied
for(int m = x; m < y; m++)
{
count = minPalPartition(str, x, m) + minPalPartition(str, m + 1, y) + 1;

answer = Math.min(answer, count);
}
return answer;
}

// main method
public static void main(String[] argvs)
{

// string for which the number of palindrome partitioning cuts is computed
String s = "pmpmmmpmmpmpmp";

// computing the size of the string
int size = s.length();

// creating an object of the class PalinPartition
PalinPartition obj = new PalinPartition();

// invoking the method minPalPartition
int minCut = obj.minPalPartition(s, 0, size - 1);

System.out.println("For the string '" + s + "' the number of minimum cuts is: " + minCut);

// string for which the number of palindrome partitioning cuts is computed
s = "pqrstu";

// computing the size of the string
size = s.length();

// invoking the method makeSquare
minCut = obj.minPalPartition(s, 0, size - 1);

System.out.println("For the string '" + s + "' the number of minimum cuts is: " + minCut);

// string for which the number of palindrome partitioning cuts is computed
s = "pmptuiutpmp";

// computing the size of the string
size = s.length();

// invoking the method makeSquare
minCut = obj.minPalPartition(s, 0, size - 1);

System.out.println("For the string '" + s + "' the number of minimum cuts is: " + minCut);

}
}

Output:

For the string 'pmpmmmpmmpmpmp' the number of minimum cuts is: 3
For the string 'pqrstu' the number of minimum cuts is: 5
For the string 'pmptuiutpmp' the number of minimum cuts is: 0

Using Iteration

Let's see the implementation of the iterative approach.

FileName: PalinPartition1.java

public class PalinPartition1 
{

// a method that returns the minimum of cuts 
// required for the palindrome partitioning of the string str
public int minPalPartition(String str)
{   
// Getting the string ize
int s = str.length();

// Creating two arrays for building the solution
// in the bottom-up manner
// Cuts[x][y] = it represents the minimum number of cuts 
//			needed for the palindrome partitioning
//			of the substring str[x ... y]
// Palin[x][y] = true if the substring str[x ... y] is
//			palindrome; otherwise, false
// Note that Cuts[x][y] is 0 only if Palin[x][y] is
// true 
int[][] Cuts = new int[s][s];
boolean[][] Palin = new boolean[s][s];

int x, y, k, Len; // variables used for the different looping 

// Any substring of the length 1 is always a palindrome
for (x = 0; x < s; x++) 
{
Palin[x][x] = true;
Cuts[x][x] = 0;
}

// Len is the length of the substring. We are building the solution in
// the bottom-up manner by taking care of all the substrings
// of the length beginning from 2 to s. The loop structures
// are the same as the Matrix Chain Multiplication
// problem

for (Len = 2; Len <= s; Len++) 
{
// For substring of the length Len, setting the different
// possible starting indexes
for (x = 0; x < s - Len + 1; x++) 
{
y = x + Len - 1; // Set ending index

// If Len is 2, then we need to
// compare the two characters. Otherwise, we need to
// check the two corner characters and the value of
// Palin[x + 1][y - 1]
if (Len == 2)
{
Palin[x][y] = (str.charAt(x) == str.charAt(y));
}
else
{
Palin[x][y] = (str.charAt(x) == str.charAt(y)) && Palin[x + 1][y - 1];
}

// If str[x ... y] is palindrome, then
// Cuts[x][y] is 0
if (Palin[x][y] == true)
{
Cuts[x][y] = 0;
}
else 
{
// Making a cut at every possible
// location beginning from x to y,
// and getting the minimum cost of the cut.
Cuts[x][y] = Integer.MAX_VALUE;
for (k = x; k <= y - 1; k++)
{
Cuts[x][y] = Integer.min(Cuts[x][y], Cuts[x][k] + Cuts[k + 1][y] + 1);
}
}
}
}

// Returning the minimum cut value for the complete
// string. that is, str[0 ... s - 1]
return Cuts[0][s - 1];
}

// main method
public static void main(String[] argvs)
{

// string for which the number of palindrome partitioning cuts is computed
String s = "pmpmmmpmmpmpmp";

// creating an object of the class PalinPartition1
PalinPartition1 obj = new PalinPartition1();

// invoking the method makeSquare
int minCut = obj.minPalPartition(s);

System.out.println("For the string '" + s + "' the number of minimum cuts is: " + minCut);

// string for which the number of palindrome partitioning cuts is computed
s = "pqrstu";

// invoking the method makeSquare
minCut = obj.minPalPartition(s);

System.out.println("For the string '" + s + "' the number of minimum cuts is: " + minCut);

// string for which the number of palindrome partitioning cuts is computed
s = "pmptuiutpmp";

// invoking the method makeSquare
minCut = obj.minPalPartition(s);

System.out.println("For the string '" + s + "' the number of minimum cuts is: " + minCut);

}
}

Output:

For the string 'pmpmmmpmmpmpmp' the number of minimum cuts is: 3
For the string 'pqrstu' the number of minimum cuts is: 5
For the string 'pmptuiutpmp' the number of minimum cuts is: 0

In the above approach, we are finding the solution using the for loops nested to a level of degree 3. Hence, the above approach is time-consuming. Therefore, the above-mentioned solution will be rejected by the interviewer most number of times, or the interviewer can ask to optimize the solution. The optimization of the above solution is mentioned below.

FileName: PalinPartition2.java

public class PalinPartition2 
{

// a method that returns the minimum of cuts 
// required for the palindrome partitioning of the string str
public int minPalPartition(String str)
{   
// Getting the string ize
int s = str.length();

// Creating two arrays for building the solution
// in the bottom-up manner
// Cuts[x] = it represents the minimum number of cuts 
//			needed for the palindrome partitioning
//			of the substring str[0 ... x]
// Palin[x][y] = true if the substring str[x ... y] is
//			palindrome; otherwise, false
// Note that Cuts[x][y] is 0 only if Palin[x][y] is
// true 
int[] Cuts = new int[s];
boolean[][] Palin = new boolean[s][s];

int x, y, k, Len; // variables used for the different looping 

// Any substring of the length 1 is always a palindrome
for (x = 0; x < s; x++) 
{
Palin[x][x] = true;
Cuts[x] = 0;
}

// Len is the length of the substring. We are building the solution in
// the bottom-up manner by taking care of all the substrings
// of the length beginning from 2 to s. The loop structures
// are the same as the Matrix Chain Multiplication
// problem

for (Len = 2; Len <= s; Len++) 
{
// For substring of the length Len, setting the different
// possible starting indexes
for (x = 0; x < s - Len + 1; x++) 
{
y = x + Len - 1; // Set ending index

// If Len is 2, then we need to
// compare the two characters. Otherwise, we need to
// check the two corner characters and the value of
// Palin[x + 1][y - 1]
if (Len == 2)
{
Palin[x][y] = (str.charAt(x) == str.charAt(y));
}
else
{
Palin[x][y] = (str.charAt(x) == str.charAt(y)) && Palin[x + 1][y - 1];
}
}
}


for (x = 0; x < s; x++) 
{
// If str[0 ... x] is palindrome, then
// Cuts[x] is 0
if (Palin[0][x] == true)
{
Cuts[x] = 0;
}
else 
{
// Making a cut at every possible
// location beginning from 0 to x,
// and getting the minimum cost of the cut.
Cuts[x] = Integer.MAX_VALUE;
for (y = 0; y < x; y++)
{
if (Palin[y + 1][x] == true && 1 + Cuts[y] < Cuts[x])
{
Cuts[x] = 1 + Cuts[y];
}
}
}
}


// Returning the minimum cut value for the complete
// string. that is, str[0 ... s - 1]
return Cuts[s - 1];
}

// main method
public static void main(String[] argvs)
{

// string for which the number of palindrome partitioning cuts is computed
String s = "pmpmmmpmmpmpmp";

// creating an object of the class PalinPartition2
PalinPartition2 obj = new PalinPartition2();

// invoking the method makeSquare
int minCut = obj.minPalPartition(s);

System.out.println("For the string '" + s + "' the number of minimum cuts is: " + minCut);

// string for which the number of palindrome partitioning cuts is computed
s = "pqrstu";

// invoking the method makeSquare
minCut = obj.minPalPartition(s);

System.out.println("For the string '" + s + "' the number of minimum cuts is: " + minCut);

// string for which the number of palindrome partitioning cuts is computed
s = "pmptuiutpmp";

// invoking the method makeSquare
minCut = obj.minPalPartition(s);

System.out.println("For the string '" + s + "' the number of minimum cuts is: " + minCut);

}
}

Output:

For the string 'pmpmmmpmmpmpmp' the number of minimum cuts is: 3
For the string 'pqrstu' the number of minimum cuts is: 5
For the string 'pmptuiutpmp' the number of minimum cuts is: 0

The solution that is provided above never uses the nesting of the for-loop to the 3rd level. Only two-level nesting of for-loop is used. Thus, it consumes less time to find the solution as compared to the last discussed approach. Hence, the above approach is better than the last discussed approach.

Next TopicRehashing in Java

← prev next →