GATE-CS-2015(Set 1) Problem 30

This problem is a question from the GATE-CS-2015(Set 1) exam. It deals with the topic of dynamic programming and asks the programmer to find the optimal split of a string such that the sum of the squares of the lengths of the resulting substrings is minimized.

Problem Statement

Given a string of length n, where n is at most 1000, and a positive integer m, find the optimal split of the string such that the sum of the squares of the lengths of the resulting substrings is minimized.

Solution

The problem can be solved using dynamic programming. Let DP[i][j] be the minimum sum of squares of the lengths of the substrings obtained by splitting the string s[i:j+1]. To compute DP[i][j], we need to consider all possible splits k such that i <= k <= j and recursively compute DP[i][k-1] and DP[k][j].

The base case is DP[i][i] = 0, since a single character is already a substring with length 1.

The recurrence relation is given by:

DP[i][j] = min(DP[i][k-1] + DP[k][j] + (j-i+1)^2)

We need to keep track of the value of k that gives us the minimum value of the function above, since this is the optimal split for the given substring.

The final answer is DP[0][n-1], which gives us the minimum sum of squares of the lengths of the substrings in the optimal split.

Code

The following code implements the solution described above:

def optimal_split(s, m):
    n = len(s)
    DP = [[float('inf')] * n for _ in range(n)]
    
    for i in range(n):
        DP[i][i] = 0
    
    for L in range(2, n+1):
        for i in range(n-L+1):
            j = i + L - 1
            for k in range(i, j):
                temp = DP[i][k] + DP[k+1][j] + (j-i+1)**2
                if temp < DP[i][j]:
                    DP[i][j] = temp
                    split[i][j] = k
   
    return DP[0][n-1]

The time complexity of this solution is O(n^3), since we compute DP[i][j] for all i and j such that i <= j. However, the space complexity is O(n^2), which is manageable for the given range of input size.