Optimal Paragraph Formatting - Problem

Advanced DP DP String Hard

You are tasked with formatting a paragraph where each character has a variable width. Given a list of words and their character widths, format them into lines with a maximum width constraint to minimize the total raggedness across all lines.

The raggedness of a line is defined as the cube of the number of extra spaces at the end of the line. The goal is to minimize the sum of raggedness across all lines in the paragraph.

Each word must fit entirely on a line (cannot be split), and there must be at least one space between words on the same line. The last line has zero raggedness regardless of trailing spaces.

Input:

words: Array of strings representing the words
widths: Array of integers where widths[i] represents the total character width of words[i]
maxWidth: Maximum allowed width per line

Output:

Return the minimum total raggedness possible

Input & Output

Example 1 — Basic Paragraph

$ Input: words = ["Hello", "World", "This", "Test"], widths = [5, 5, 4, 4], maxWidth = 12

› Output: 125

💡 Note: Optimal formatting: Line 1: 'Hello World' (width=11, raggedness=1³=1), Line 2: 'This Test' (width=9, raggedness=(12-9)³=27), Last line has no raggedness. Total: 1 + 27 = 28. Wait, let me recalculate: Better formatting might be 'Hello' alone (raggedness=7³=343) then 'World This Test' (width=14 > 12, invalid). Actually 'Hello World' + 'This Test' gives 1 + 27 = 28 as minimum.

Example 2 — Single Line

$ Input: words = ["Hi", "There"], widths = [2, 5], maxWidth = 10

› Output: 0

💡 Note: Both words fit on one line: 'Hi There' has width 2+1+5=8 ≤ 10. Since this is the last (and only) line, raggedness = 0.

Example 3 — Forced Splits

$ Input: words = ["A", "B", "C"], widths = [1, 1, 1], maxWidth = 2

› Output: 2

💡 Note: Each word must be on its own line due to width constraint. Line 1: 'A' (raggedness=1³=1), Line 2: 'B' (raggedness=1³=1), Line 3: 'C' (last line, no raggedness). Total: 1 + 1 = 2.

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 20
widths[i] > 0
1 ≤ maxWidth ≤ 100
Each word must fit within maxWidth

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22 A Adobe 18

The key insight is to use dynamic programming to find the optimal line breaks that minimize total raggedness. The problem has optimal substructure: the best way to format words i to n depends on where to end the first line and the optimal formatting of remaining words. Best approach is bottom-up DP with Time: O(n²), Space: O(n).

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n²) Space: O(n)

Create a DP array where dp[i] represents minimum raggedness for words from index i to end. Fill the array from right to left, trying all possible line endings.

Memoized Dynamic Programming

⏱️ Time: O(n × maxWidth) Space: O(n × maxWidth)

Same recursive approach as brute force, but store results of each (word_index, current_width) state in a cache to avoid recalculating the same subproblems.

Recursive Brute Force

⏱️ Time: O(2ⁿ) Space: O(n)

For each word, try putting it on the current line or starting a new line. Recursively calculate minimum raggedness for remaining words and add current line's raggedness.

Bottom-Up Dynamic Programming — Algorithm Steps

Create dp array of size n+1
Initialize dp[n] = 0 (base case)
For each position i from n-1 to 0, try all possible line endings
Update dp[i] with minimum raggedness among all choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[n] = 0, all others = infinity

Fill Backwards

For each position i, try all line endings j

Calculate Cost

Line cost = raggedness + dp[j+1]

Take Minimum

dp[i] = min of all possibilities

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <limits.h>

int solution(int* widths, int n, int maxWidth) {
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    for (int i = 0; i < n; i++) {
        dp[i] = INT_MAX;
    }
    dp[n] = 0; // Base case: no words left
    
    for (int i = n - 1; i >= 0; i--) {
        // Try different line endings starting from word i
        int lineWidth = 0;
        for (int j = i; j < n; j++) {
            if (j == i) {
                lineWidth = widths[j];
            } else {
                lineWidth += 1 + widths[j]; // space + word width
            }
            
            if (lineWidth > maxWidth) {
                break; // Can't fit more words
            }
            
            // Calculate cost for this line
            if (j == n - 1) { // Last line has no raggedness
                if (dp[j + 1] < dp[i]) {
                    dp[i] = dp[j + 1];
                }
            } else {
                int raggedness = pow(maxWidth - lineWidth, 3);
                int cost = raggedness + dp[j + 1];
                if (cost < dp[i]) {
                    dp[i] = cost;
                }
            }
        }
    }
    
    int result = dp[0];
    free(dp);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin); // skip words
    
    fgets(line, sizeof(line), stdin);
    int widths[100];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        widths[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int maxWidth;
    scanf("%d", &maxWidth);
    
    int result = solution(widths, n, maxWidth);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each word position i, we try all possible line endings j from i to n, giving nested loops

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store minimum raggedness for each position

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Optimal Paragraph Formatting - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler