[Coding Made Simple] Text Justification

Given a sequence of words, and a limit on the number of characters that can be put in one line(line width).

Put line breaks in the given sequence such that the cost of padding spaces is minimal.

The cost of padding spaces is defined as the sum of the square of padding spaces of each line.

Algorithm:

1. Fill a 2D cost array cost[i][j]. cost[i][j] is the cost of putting strs[i]....strs[j] on one line, if they can't be put in the same line, Integer.MAX_VALUE is used to indicate that.

　When computing this cost, we need to add each string's length from strs[i] to strs[j], this operation takes O(n) time. To get a O(1) time, prefix sum technique is used.

2. minCost[i] is the min cost possible from strs[0] to strs[i]; the final answer is minCost[n - 1].

　lineBreakIdx[i] is the last string's index on the previous line. 

State: 

1. If strs[0] to strs[i] can be put in the same line.

　 minCost[i] = cost[0][i]; 

　 lineBreakIdx[i] = i;

2. If strs[0] to strs[i] can not be put in the same line, then we need to find a split point that gives a minimal cost.

     minCost[i] = min { minCost[j] + cost[j + 1][i] }, for j is from 0 to i - 1 and strs[j + 1] to strs[i] can be put in the same line.

     j is the split index. strs[0] to strs[j] are put on one line; strs[j + 1] to strs[i] are put on anothre line.

Why dynamic programming?

To compute minCost[i], we need to compute the min costs of its subproblems. To compute minCost[i + 1], we possbily need to compute minCost[i], this is a clear overlapping subproblems pattern.

import java.util.ArrayList;

public class TextJustification {
    private ArrayList<String> brokeSen;
    public int getMinCost(String[] strs, int maxWidth) {
        brokeSen = new ArrayList<String>();
        if(strs == null || strs.length == 0) {
            return 0;
        }
        int[][] cost = new int[strs.length][strs.length];
        //minCost[i]: the min cost of padding spaces for strs[0....i];
        int[] minCost = new int[strs.length];
        int[] lineBreakIdx = new int[strs.length];
        int[] prefixSum = new int[strs.length + 1];
        prefixSum[0] = 0;
        for(int i = 1; i <= strs.length; i++) {
            prefixSum[i] = prefixSum[i - 1] + strs[i - 1].length();
        }
        for(int i = 0; i < strs.length; i++) {
            for(int j = i; j < strs.length; j++) {
                int len = prefixSum[j + 1] - prefixSum[i] + j - i;
                if(len <= maxWidth) {
                    cost[i][j] = (maxWidth - len) * (maxWidth - len); 
                }
                else {
                    cost[i][j] = Integer.MAX_VALUE;
                }
            }
        }
        for(int i = 0; i < strs.length; i++) {
            minCost[i] = cost[0][i];
            if(minCost[i] < Integer.MAX_VALUE) {
                lineBreakIdx[i] = i;
            }
            else {
                for(int j = 0; j < i; j++) {
                    if(cost[j + 1][i] < Integer.MAX_VALUE && minCost[j] + cost[j + 1][i] < minCost[i]) {
                        minCost[i] = minCost[j] + cost[j + 1][i];
                        lineBreakIdx[i] = j;
                    }
                }                
            }            
        }
        int endIdx = strs.length - 1;
        StringBuilder sb;
        while(lineBreakIdx[endIdx] != endIdx) {
            sb = new StringBuilder();
            for(int i = lineBreakIdx[endIdx] + 1; i < endIdx; i++) {
                sb.append(strs[i] + " ");               
            }
            sb.append(strs[endIdx]);
               brokeSen.add(sb.toString()); 
            endIdx = lineBreakIdx[endIdx];
        }
        sb = new StringBuilder();
        for(int i = 0; i < endIdx; i++) {
            sb.append(strs[i] + " ");
        }
        sb.append(strs[endIdx]);
        brokeSen.add(sb.toString());
        return minCost[strs.length - 1];
    }
    public static void main(String[] args) {
        String[] strs1 = {"tushar", "roy", "likes", "to", "code"};
        String[] strs2 = {"a", "b", "c", "d", "e"};
        TextJustification test = new TextJustification();
        System.out.println(test.getMinCost(strs1, 10));
        for(int i = 0; i < test.brokeSen.size(); i++) {
            System.out.println(test.brokeSen.get(i));
        }
        System.out.println(test.getMinCost(strs2, 10));
        for(int i = 0; i < test.brokeSen.size(); i++) {
            System.out.println(test.brokeSen.get(i));
        }
    }
}

Related Problems

[LeetCode 68] Text Justification