GATE-CS-2015(Set 2) Problem 9

This problem is about dynamic programming. Given a string of n letters, we must find the minimum number of cuts needed to partition the string into n single letter substrings such that each substring is a palindrome.

We can solve this problem using dynamic programming by building a table that stores the minimum number of cuts needed to partition a substring of the given string into palindromic substrings. We first initialize the table with the maximum number of cuts possible, which is n-1. We then fill in the table from bottom to top and left to right.

We can define the base cases as follows:

• If the substring is empty or a single character, it is already a palindrome and no cuts are needed. The minimum number of cuts is 0.
• If the substring is a palindrome, no cuts are needed. The minimum number of cuts is 0.

For a substring of length greater than 1, we can check if it is a palindrome. If it is, we update the table with a value of 0. Otherwise, we can try all possible ways to partition the substring into smaller substrings and choose the partition that results in the minimum number of cuts. To check if a substring is a palindrome, we can use a two-pointer approach where we start from the ends of the substring and compare each character.

Here is the Python code to solve this problem:

def palindrome_partitions(s):
    n = len(s)
    table = [[0 for j in range(n)] for i in range(n)]
    palindromes = [[False for j in range(n)] for i in range(n)]
    
    # Initialize base cases
    for i in range(n):
        table[i][i] = 0
        palindromes[i][i] = True
    
    for l in range(2, n+1):
        for i in range(n-l+1):
            j = i + l - 1
            if l == 2:
                palindromes[i][j] = (s[i] == s[j])
            else:
                palindromes[i][j] = (s[i] == s[j] and palindromes[i+1][j-1])
            if palindromes[i][j]:
                table[i][j] = 0
            else:
                table[i][j] = n-1 # maximum number of cuts
                for k in range(i, j):
                    table[i][j] = min(table[i][j], table[i][k]+table[k+1][j]+1)
    
    return table[0][n-1]

s = "ababbbabbababa"
print(palindrome_partitions(s)) # Output: 3

The time complexity of this algorithm is O(n^3) and the space complexity is O(n^2). However, we can optimize the space complexity to O(n) by using a 1D array instead of a 2D array to store the table values. We only need to keep track of the previous row of values, so we can overwrite the current row after each iteration.

def palindrome_partitions(s):
    n = len(s)
    table = [n-1 for i in range(n)]
    prev_row = [0 for i in range(n)]
    palindromes = [[False for j in range(n)] for i in range(n)]
    
    # Initialize base cases
    for i in range(n):
        table[i] = 0
        palindromes[i][i] = True
    
    for l in range(2, n+1):
        for i in range(n-l+1):
            j = i + l - 1
            if l == 2:
                palindromes[i][j] = (s[i] == s[j])
            else:
                palindromes[i][j] = (s[i] == s[j] and palindromes[i+1][j-1])
            if palindromes[i][j]:
                table[j] = 0
            else:
                table[j] = n-1 # maximum number of cuts
                for k in range(i, j):
                    table[j] = min(table[j], prev_row[k]+table[k+1]+1)
        prev_row = table[:]
    
    return table[n-1]

s = "ababbbabbababa"
print(palindrome_partitions(s)) # Output: 3

In conclusion, we can solve the palindrome partitioning problem using dynamic programming by building a table that stores the minimum number of cuts needed to partition a substring into palindromic substrings. The time complexity of the algorithm is O(n^3) and the space complexity is O(n^2) or O(n) with optimizations.