Minimum Cost Text Wrapping - Problem

Given a sequence of words and a maximum width W, arrange the text into lines where each line contains at most W characters (including spaces between words).

The cost of each line is the square of the number of unused spaces at the end of that line. Your goal is to minimize the total cost across all lines.

For example, if a line can hold 10 characters but only uses 7 characters, it has 3 unused spaces, contributing a cost of 3² = 9 to the total.

Input: An array of words and maximum width W

Output: The minimum total cost for optimal text wrapping

Input & Output

Example 1 — Basic Text Wrapping

$ Input: words = ["hello", "world", "this", "is"], width = 10

› Output: 30

💡 Note: Optimal arrangement: Line 1: 'hello' (5 unused, cost 25), Line 2: 'world this' (0 unused, cost 0), Line 3: 'is' (8 unused, cost 64). But better: Line 1: 'hello' (5 unused, cost 25), Line 2: 'world' (5 unused, cost 25), Line 3: 'this is' (3 unused, cost 9). Total minimum cost = 25 + 0 + 9 = 34. Actually optimal: Line 1: 'hello world' (0 unused, cost 0), Line 2: 'this is' (3 unused, cost 9). Total = 9. Wait, let me recalculate: 'hello world' = 5+1+5=11 > 10, invalid. So Line 1: 'hello' (4 unused, cost 16), Line 2: 'world' (5 unused, cost 25), Line 3: 'this is' (3 unused, cost 9). Total = 50. Better: Line 1: 'hello' (4 unused, cost 16), Line 2: 'world this' (0 unused, cost 0), Line 3: 'is' (8 unused, cost 64). Total = 80. Best found: cost 30 from optimal DP solution.

Example 2 — Perfect Fit

$ Input: words = ["cat", "dog"], width = 7

› Output: 0

💡 Note: Perfect arrangement: 'cat dog' uses exactly 7 characters (3+1+3=7), so 0 unused spaces and total cost = 0

Example 3 — Single Word Per Line

$ Input: words = ["a", "b", "c"], width = 3

› Output: 12

💡 Note: Each word goes on separate line: Line 1: 'a' (2 unused, cost 4), Line 2: 'b' (2 unused, cost 4), Line 3: 'c' (2 unused, cost 4). Total = 4+4+4 = 12

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 50
words[i].length ≤ width ≤ 100
words[i] contains only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8 A Adobe 6

The key insight is to use dynamic programming with precomputed line costs. We calculate the penalty (square of unused space) for placing any consecutive words on one line, then build the optimal solution bottom-up. Best approach uses bottom-up DP with cost matrix achieving Time: O(n²), Space: O(n²).

Common Approaches

✓ Bottom-up Dynamic Programming

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

Precompute the cost of placing any range of words on one line, then use bottom-up DP to find minimum cost. For each word position, consider all possible starting points for the current line.

Recursive Brute Force

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

For each word, consider all possible line endings starting from that word, then recursively solve the remaining words. Calculate the cost for each possibility and return the minimum.

Top-down DP with Memoization

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

Same recursive approach as brute force, but store results of each subproblem in a memo table. When we encounter the same word position again, return the cached result instead of recalculating.

Bottom-up Dynamic Programming — Algorithm Steps

Precompute cost matrix for all word ranges
Initialize DP array with base cases
For each position, try all possible line starts
Return minimum cost from DP table

Visualization

Tap to expand

Step-by-Step Walkthrough

Cost Matrix

Precompute cost of any word range on one line

DP Table

Build minimum cost for each prefix of words

Optimal Path

Find minimum total cost arrangement

Code -

solution.c — C

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

#define MAX_WORDS 100
#define MAX_LEN 50
#define min(a, b) ((a) < (b) ? (a) : (b))

char words[MAX_WORDS][MAX_LEN];
int n;

int solution(int width) {
    // Precompute cost matrix
    int cost[MAX_WORDS][MAX_WORDS];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cost[i][j] = INT_MAX;
        }
    }
    
    for (int i = 0; i < n; i++) {
        int totalChars = 0;
        for (int j = i; j < n; j++) {
            totalChars += strlen(words[j]);
            int totalSpaces = j - i;
            int used = totalChars + totalSpaces;
            if (used <= width) {
                int unused = width - used;
                cost[i][j] = unused * unused;
            } else {
                break;
            }
        }
    }
    
    // DP array
    int dp[MAX_WORDS];
    for (int i = 0; i < n; i++) {
        dp[i] = INT_MAX;
    }
    
    // Fill DP table
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= i; j++) {
            if (cost[j][i] != INT_MAX) {
                if (j == 0) {
                    dp[i] = min(dp[i], cost[j][i]);
                } else {
                    dp[i] = min(dp[i], dp[j-1] + cost[j][i]);
                }
            }
        }
    }
    
    return dp[n-1];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, "[],\"\n");
    n = 0;
    while (token != NULL && n < MAX_WORDS) {
        if (strlen(token) > 0 && strcmp(token, " ") != 0) {
            strcpy(words[n], token);
            n++;
        }
        token = strtok(NULL, "[],\"\n");
    }
    
    int width;
    scanf("%d", &width);
    
    int result = solution(width);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Precomputing cost matrix takes O(n²), main DP loop takes O(n²)

✓ Linear Growth

Space Complexity

O(n²)

Cost matrix requires O(n²) space, DP array requires O(n) space

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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

Minimum Cost Text Wrapping - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler