Find the Substring With Maximum Cost

Find the Substring With Maximum Cost - Problem

You are given a string s, a string chars of distinct characters, and an integer array vals of the same length as chars.

The cost of the substring is the sum of the values of each character in the substring. The cost of an empty string is considered 0.

The value of the character is defined in the following way:

If the character is not in the string chars, then its value is its corresponding position (1-indexed) in the alphabet.
- For example, the value of 'a' is 1, the value of 'b' is 2, and so on. The value of 'z' is 26.
Otherwise, assuming i is the index where the character occurs in the string chars, then its value is vals[i].

Return the maximum cost among all substrings of the string s.

Input & Output

Example 1 — Basic Case

$ Input: s = "adaa", chars = "d", vals = [-1000]

› Output: 2

💡 Note: Character 'd' has value -1000, others use alphabet positions: 'a'=1. Best substring is "aa" at the end with cost 1+1=2.

Example 2 — All Custom Values

$ Input: s = "abc", chars = "abc", vals = [-1,-1,1]

› Output: 1

💡 Note: All characters have custom values: 'a'=-1, 'b'=-1, 'c'=1. Best substring is "c" with cost 1.

Example 3 — Empty Substring Optimal

$ Input: s = "z", chars = "z", vals = [-100]

› Output: 0

💡 Note: Character 'z' has value -100, which is negative. Empty substring has cost 0, which is better.

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ chars.length ≤ 26
chars.length = vals.length
1 ≤ vals[i] ≤ 2000
s and chars consist of lowercase English letters
All characters in chars are distinct

Visualization

Tap to expand

Asked in

G Google 12 F Facebook 8 A Amazon 15 M Microsoft 6

This problem transforms a substring cost calculation into a maximum subarray problem. The key insight is to first map each character to its value (custom or alphabet position), then apply Kadane's algorithm to find the maximum sum of any contiguous subarray. The optimal solution runs in O(n) time with O(1) space.

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force

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

Generate every possible substring of s, calculate the cost of each substring by summing character values, and return the maximum cost found.

Kadane's Algorithm (Optimal)

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

First create a mapping of character values, then convert the string to an array of values. Apply Kadane's algorithm to find the maximum sum subarray, which corresponds to the maximum cost substring.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

// Function to get character value
int getCharValue(char c, const char* chars, int* vals, int charsLen) {
    // First check if character is in chars array
    for (int i = 0; i < charsLen; i++) {
        if (chars[i] == c) {
            return vals[i];
        }
    }
    // If not found, return 1-indexed alphabet position
    return c - 'a' + 1;
}

// Parse array from string format like [-1000] or [-1,-1,1]
void parseValsArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip to opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number (handle negative)
        char* endptr;
        arr[(*size)++] = (int)strtol(p, &endptr, 10);
        p = endptr;
    }
}

int maximumCostSubstring(const char* s, const char* chars, int* vals, int charsLen) {
    int n = strlen(s);
    if (n == 0) return 0;
    
    // Use Kadane's algorithm for maximum subarray sum
    int maxCost = 0;  // Empty string has cost 0
    int currentSum = 0;
    
    for (int i = 0; i < n; i++) {
        int charValue = getCharValue(s[i], chars, vals, charsLen);
        currentSum += charValue;
        
        // Update maximum if current sum is better
        if (currentSum > maxCost) {
            maxCost = currentSum;
        }
        
        // If current sum becomes negative, reset to 0
        // (equivalent to starting a new subarray)
        if (currentSum < 0) {
            currentSum = 0;
        }
    }
    
    return maxCost;
}

int main() {
    char s[1001];
    char chars[1001];
    char valsStr[10001];
    
    // Read input
    fgets(s, sizeof(s), stdin);
    fgets(chars, sizeof(chars), stdin);
    fgets(valsStr, sizeof(valsStr), stdin);
    
    // Remove newlines
    s[strcspn(s, "\n")] = 0;
    chars[strcspn(chars, "\n")] = 0;
    valsStr[strcspn(valsStr, "\n")] = 0;
    
    // Parse vals array
    int vals[1001];
    int valsLen;
    parseValsArray(valsStr, vals, &valsLen);
    
    int charsLen = strlen(chars);
    
    int result = maximumCostSubstring(s, chars, vals, charsLen);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.5K Views

Medium Frequency

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