Minimum Cost to Separate Sentence Into Rows

Minimum Cost to Separate Sentence Into Rows - Problem

You are given a string sentence containing words separated by spaces, and an integer k. Your task is to separate sentence into rows where the number of characters in each row is at most k.

You may assume that sentence does not begin or end with a space, and the words in sentence are separated by a single space. You can split sentence into rows by inserting line breaks between words in sentence. A word cannot be split between two rows. Each word must be used exactly once, and the word order cannot be rearranged.

Adjacent words in a row should be separated by a single space, and rows should not begin or end with spaces. The cost of a row with length n is (k - n)², and the total cost is the sum of the costs for all rows except the last one.

Example: If sentence = "i love leetcode" and k = 12:
• Separating sentence into "i", "love", and "leetcode" has a cost of (12 - 1)² + (12 - 4)² = 121 + 64 = 185
• Separating sentence into "i love", and "leetcode" has a cost of (12 - 6)² = 36

Return the minimum possible total cost of separating sentence into rows.

Input & Output

Example 1 — Basic Case

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

› Output: 36

💡 Note: Split into "i love" (6 chars) and "leetcode" (8 chars). Cost = (12-6)² = 36. Last row has no cost.

Example 2 — Single Word Per Row

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

› Output: 9

💡 Note: "hello world" = 11 chars > 8, so must split into "hello" (5 chars) and "world" (5 chars). Cost = (8-5)² = 9 for first row, 0 for last row.

Example 3 — All Words Fit

$ Input: sentence = "a b c", k = 10

› Output: 0

💡 Note: All words fit in one row: "a b c" (5 chars ≤ 10). Since it's the last (and only) row, cost = 0.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 8

The key insight is to use dynamic programming where each position represents the minimum cost to format remaining words. The optimal approach uses bottom-up DP to avoid recursion overhead. 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 cost to format words from index i to end. Fill the array backwards, considering all valid row endings for each position.

Brute Force Recursion

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

For each word position, try starting a new row from that position and recursively solve for remaining words. Calculate cost for each possibility and return minimum.

Memoization (Top-Down DP)

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

Same recursive approach as brute force, but cache results for each starting position to avoid redundant calculations. This eliminates overlapping subproblems.

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 valid row endings
dp[i] = min cost among all valid choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create DP array, set dp[n] = 0

Fill Backwards

For each position, try all valid row endings

Optimal Cost

dp[0] contains minimum cost for entire sentence

Code -

solution.c — C

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

int solution(char* sentence, int k) {
    char words[100][100];
    int n = 0;
    
    char* token = strtok(sentence, " ");
    while (token != NULL && n < 100) {
        strcpy(words[n], token);
        n++;
        token = strtok(NULL, " ");
    }
    
    int dp[101] = {0};
    
    for (int i = n - 1; i >= 0; i--) {
        dp[i] = INT_MAX;
        int length = 0;
        
        for (int j = i; j < n; j++) {
            if (length > 0) {
                length += 1;  // space
            }
            length += strlen(words[j]);
            
            if (length > k) {
                break;
            }
            
            int cost = 0;
            if (j == n - 1) {  // last row has no cost
                cost = 0;
            } else {
                cost = (k - length) * (k - length);
            }
            
            if (cost + dp[j + 1] < dp[i]) {
                dp[i] = cost + dp[j + 1];
            }
        }
    }
    
    return dp[0];
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char sentence[1000];
    int k;
    
    fgets(sentence, sizeof(sentence), stdin);
    sentence[strcspn(sentence, "\n")] = 0;
    
    scanf("%d", &k);
    
    int result = solution(sentence, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

n positions × n possible row lengths × n word length calculations

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n to store minimum costs

⚡ Linearithmic Space

21.0K Views

Medium Frequency

~25 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler