The Painter's Partition Problem Part I

(http://leetcode.com/2011/04/the-painters-partition-problem.html)

You have to paint N boards of lenght {A0, A1, A2 ... AN-1}. There are K painters available and you are also given how much time a painter takes to paint 1 unit of board. You have to get this job done as soon as possible under the constraints that any painter will only paint continues sections of board, say board {2, 3, 4} or only board {1} or nothing but not board {2, 4, 5}.

We define M[n, k] as the optimum cost of a partition arrangement with n total blocks from the first block and k patitions, so

                 n              n-1
M[n, k] = min { max { M[j, k-], ∑ Ai } }
                j=1             i=j

The base cases are:

M[, k] = A0
         n-1
M[n, ] = Σ Ai
         i=0

Therefore, the brute force solution is:

int sum(int A[], int from, int to)
{
    int total = ;
    for (int i = from; i <= to; i++)
        total += A[i];
    return total;
}

int partition(int A[], int n, int k)
{
    if (n <=  || k <= )
        return -;
    if (n == )
        return A[];
    if (k == )
        return sum(A, , n-);

    int best = INT_MAX;
    for (int j = ; j <= n; j++)
        best = min(best, max(partition(A, j, k-), sum(A, j, n-)));

    return best;
}

It is exponential in run time complexity due to re-computation of the same values over and over again.

The DP solution:

int findMax(int A[], int n, int k)
{
    int M[n+][k+];
    int sum[n+];
    for (int i = ; i <= n; i++)
        sum[i] = sum[i-] + A[i-];

    for (int i = ; i <= n; i++)
        M[i][] = sum[i];
    for (int i = ; i <= k; i++)
        M[][k] = A[];

    for (int i = ; i <= k; i++)
    {
        for (int j = ; j <= n; j++)
        {
            int best = INT_MAX;
            for (int p = ; p <= j; p++)
            {
                best = min(best, max(M[p][i-], sum[j]-sum[p]));
            }
            M[j][i] = best;
        }
    }
    return M[n][k];
}

Run time: O(kN*N), space complexity: O(kN).