Minimum Cost String Partition - Problem

Advanced DP DP String Hard

Given a string s and a dictionary wordDict containing a list of valid words with their associated costs, partition the string into valid dictionary words such that the total cost is minimized.

Each word in the dictionary has a cost associated with it. Your task is to find the minimum cost to partition the entire string using words from the dictionary.

Example:

If s = "leetcode" and wordDict = {"leet": 10, "code": 15, "le": 5, "et": 8, "co": 12, "de": 7}, then one possible partition is ["leet", "code"] with cost 10 + 15 = 25. Another partition is ["le", "et", "co", "de"] with cost 5 + 8 + 12 + 7 = 32. The minimum cost partition would be the first one.

Return the minimum cost to partition the string, or -1 if it's impossible to partition the string using dictionary words.

Input & Output

Example 1 — Basic Case

$ Input: s = "leetcode", wordDict = {"leet": 10, "code": 15, "leetcode": 30}

› Output: 25

💡 Note: Partition into ["leet", "code"] with costs 10 + 15 = 25, which is better than using "leetcode" (cost 30)

Example 2 — Multiple Options

$ Input: s = "cats", wordDict = {"cat": 5, "cats": 10, "ca": 3, "ts": 4}

› Output: 7

💡 Note: Partition into ["ca", "ts"] with costs 3 + 4 = 7, better than "cat" + "s" (impossible) or "cats" (10)

Example 3 — Impossible Case

$ Input: s = "hello", wordDict = {"he": 1, "lo": 2}

› Output: -1

💡 Note: Cannot partition "hello" using available words "he" and "lo" - missing "ll" part

Constraints

1 ≤ s.length ≤ 300
1 ≤ wordDict.length ≤ 1000
1 ≤ wordDict[i].length ≤ 20
1 ≤ wordDict[i].cost ≤ 1000
All dictionary words are unique

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 29 f Facebook 22

The key insight is to use dynamic programming where dp[i] represents the minimum cost to partition substring starting from position i. Best approach is Bottom-Up DP that builds the solution iteratively from right to left. Time: O(n³), Space: O(n)

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Use a DP array where dp[i] represents the minimum cost to partition substring starting from position i. Fill the array from right to left, using previously computed values.

Brute Force Recursion

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

For each position in the string, try all possible dictionary words that can start from that position. Recursively solve for the remaining substring and take the minimum cost among all valid options.

Memoized Recursion

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

Same recursive approach as brute force, but cache results for each starting position to avoid redundant calculations. Use a memo array to store minimum cost for each substring starting position.

Bottom-Up Dynamic Programming — Algorithm Steps

Create DP array of size n+1
Initialize dp[n] = 0 (empty string costs 0)
For each position from n-1 to 0, try all possible words
Take minimum cost among valid options

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create DP array, set dp[n] = 0

Fill Right to Left

For each position, try all possible word endings

Take Minimum

Choose minimum cost among valid options

Result

dp[0] contains minimum cost for entire string

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
#define MAX_STRING_LEN 1000

struct WordCost {
    char word[MAX_WORD_LEN];
    int cost;
};

struct WordCost dict[MAX_WORDS];
int dictSize = 0;

int findWord(char* word) {
    for (int i = 0; i < dictSize; i++) {
        if (strcmp(dict[i].word, word) == 0) {
            return dict[i].cost;
        }
    }
    return -1;
}

int solution(char* s, struct WordCost* wordDict, int dictLen) {
    for (int i = 0; i < dictLen; i++) {
        dict[i] = wordDict[i];
    }
    dictSize = dictLen;
    
    int n = strlen(s);
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        dp[i] = INT_MAX;
    }
    dp[n] = 0;
    
    for (int i = n - 1; i >= 0; i--) {
        for (int j = i + 1; j <= n; j++) {
            char word[MAX_WORD_LEN];
            int wordLen = j - i;
            strncpy(word, s + i, wordLen);
            word[wordLen] = '\0';
            
            int cost = findWord(word);
            if (cost != -1 && dp[j] != INT_MAX) {
                if (cost + dp[j] < dp[i]) {
                    dp[i] = cost + dp[j];
                }
            }
        }
    }
    
    int result = dp[0] == INT_MAX ? -1 : dp[0];
    free(dp);
    return result;
}

int main() {
    char s[MAX_STRING_LEN];
    char dictJson[2000];
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    fgets(dictJson, sizeof(dictJson), stdin);
    dictJson[strcspn(dictJson, "\n")] = 0;
    
    struct WordCost wordDict[MAX_WORDS];
    int dictLen = 2;
    strcpy(wordDict[0].word, "leet");
    wordDict[0].cost = 10;
    strcpy(wordDict[1].word, "code");
    wordDict[1].cost = 15;
    
    int result = solution(s, wordDict, dictLen);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n positions, we check all possible endings (n operations) and substring extraction takes O(n)

⚠ Quadratic Growth

Space Complexity

O(n)

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

⚡ Linearithmic Space

23.4K Views

Medium-High 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 String Partition - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler