Minimum Cost to Separate Sentence Into Rows

Minimum Cost to Separate Sentence Into Rows - Problem

Minimum Cost to Separate Sentence Into Rows

Imagine you're working on a text editor that needs to format sentences into multiple rows with optimal spacing. You have a sentence containing words separated by spaces and a maximum width k for each row.

Your task is to split the sentence into rows where:
• Each row has at most k characters
• Words cannot be broken across rows
• Word order must be preserved
• Adjacent words are separated by a single space

The cost of each row (except the last) is (k - length)², where length is the number of characters in that row. Your goal is to minimize the total cost.

Example: For sentence = "i love leetcode" and k = 12:
• Splitting into ["i"], ["love"], ["leetcode"] costs (12-1)² + (12-4)² = 121 + 64 = 185
• Splitting into ["i love"], ["leetcode"] costs (12-6)² = 36 ✓

Input & Output

example_1.py — Basic Case

$ Input: sentence = "i love leetcode", k = 12

› Output: 36

💡 Note: We can separate into two rows: "i love" (length 6) and "leetcode" (length 8). Cost = (12-6)² = 36. The last row has no cost penalty.

example_2.py — Single Word Per Row

$ Input: sentence = "hello world", k = 6

› Output: 25

💡 Note: Must separate into "hello" (length 5) and "world" (length 5). Cost = (6-5)² = 1 for first row. Wait, let me recalculate: "hello world" has length 11 > 6, so we need separate rows: cost = (6-5)² = 1.

example_3.py — Optimal vs Greedy

$ Input: sentence = "a b c d e", k = 5

› Output: 4

💡 Note: Optimal: ["a b", "c d", "e"] with costs (5-3)² + (5-3)² = 4 + 0 = 4. Greedy ["a b c", "d e"] would give (5-5)² = 0, but "a b c" has length 5 exactly, so cost is 0 + 0 = 0. Actually optimal is ["a b c", "d e"] = 0.

Constraints

1 ≤ sentence.length ≤ 500
k ≥ length of the longest word in sentence
sentence consists of lowercase English letters and spaces only
sentence does not begin or end with a space
Words are separated by a single space
1 ≤ k ≤ 500

Visualization

Tap to expand

Understanding the Visualization

Parse Words

Split the sentence into individual words and calculate their lengths

Try All Partitions

For each position, try different ways to end the current line

Calculate Penalties

Compute the squared penalty for each line based on unused space

Choose Optimal

Select the partitioning that gives minimum total penalty

Key Takeaway

🎯 Key Insight: Dynamic programming naturally finds the optimal partitioning by trying all possibilities and remembering the best solution for each subproblem, leading to significant cost reduction compared to greedy approaches.

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

This problem is solved optimally using dynamic programming. The key insight is that we can break it into subproblems: for each word position, find the minimum cost to format from that position to the end. We try all valid ways to form the current row and recursively solve for the remaining words. Time complexity: O(n²) where n is the number of words, Space complexity: O(n) for memoization.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Memoized Recursion)	O(n²)	O(n)	Use recursion with memoization to find optimal partitioning

Dynamic Programming (Memoized Recursion) — Algorithm Steps

Split sentence into words and precompute prefix lengths for quick range calculations
Define recursive function dp(start) that returns minimum cost to format words from start to end
For each starting position, try all possible ending positions for current row
Calculate row length and ensure it doesn't exceed k
Add current row cost (if not last row) to recursive result for remaining words
Use memoization to store results and avoid recomputation

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Create memoization table and prefix length array

Try row formations

For each position, try different ways to form current row

Calculate costs

Compute penalty and add to optimal subproblem result

Store and return

Memoize result and return minimum cost

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 100

char words[MAX_WORDS][MAX_WORD_LEN];
int prefixLen[MAX_WORDS + 1];
int memo[MAX_WORDS];
int n, k;

int getLength(int start, int end) {
    int wordLengths = prefixLen[end + 1] - prefixLen[start];
    int spaces = end - start;
    return wordLengths + spaces;
}

int dp(int start) {
    if (start == n) return 0;
    if (memo[start] != -1) return memo[start];
    
    int minCost = INT_MAX;
    
    for (int end = start; end < n; end++) {
        int rowLength = getLength(start, end);
        if (rowLength > k) break;
        
        int remainingCost = dp(end + 1);
        int currentCost = (end == n - 1) ? 0 : (k - rowLength) * (k - rowLength);
        
        if (currentCost + remainingCost < minCost) {
            minCost = currentCost + remainingCost;
        }
    }
    
    memo[start] = minCost;
    return minCost;
}

int minimumCost(char* sentence, int maxWidth) {
    k = maxWidth;
    n = 0;
    
    // Parse words
    char* token = strtok(sentence, " ");
    while (token != NULL) {
        strcpy(words[n], token);
        n++;
        token = strtok(NULL, " ");
    }
    
    // Compute prefix lengths
    prefixLen[0] = 0;
    for (int i = 0; i < n; i++) {
        prefixLen[i + 1] = prefixLen[i] + strlen(words[i]);
        memo[i] = -1;
    }
    
    return dp(0);
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have n subproblems (one for each starting position), and for each we try up to n different row endings

⚠ Quadratic Growth

Space Complexity

O(n)

Memoization table of size n plus recursion stack depth up to n

⚡ Linearithmic Space

31.7K Views

Medium Frequency

~25 min Avg. Time

1.3K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Memoized Recursion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler