Get Equal Substrings Within Budget

Get Equal Substrings Within Budget - Problem

You are given two strings s and t of the same length and an integer maxCost. You want to change s to t. Changing the i-th character of s to the i-th character of t costs |s[i] - t[i]| (i.e., the absolute difference between the ASCII values of the characters).

Return the maximum length of a substring of s that can be changed to be the same as the corresponding substring of t with a cost less than or equal to maxCost.

If there is no substring from s that can be changed to its corresponding substring from t, return 0.

Input & Output

Example 1 — Basic Transformation

$ Input: s = "abcd", t = "bcdf", maxCost = 3

› Output: 3

💡 Note: We can change "abc" to "bcd" with cost |a-b| + |b-c| + |c-d| = 1 + 1 + 1 = 3, giving us a substring of length 3.

Example 2 — Single Character

$ Input: s = "abcd", t = "cdef", maxCost = 3

› Output: 1

💡 Note: Each character transformation costs 2, so with maxCost = 3, we can only transform 1 character at a time.

Example 3 — No Budget

$ Input: s = "abcd", t = "acde", maxCost = 0

› Output: 1

💡 Note: Characters 'a' at position 0 match (cost 0), so we can have a substring of length 1 with no cost.

Constraints

1 ≤ s.length, t.length ≤ 10⁵
0 ≤ maxCost ≤ 10⁶
s and t contain only lowercase English letters

Visualization

Tap to expand

Asked in

f Facebook 25 a Amazon 20 G Google 15

The sliding window approach is optimal - expand the window when budget allows and contract when exceeded. Key insight: Each character is visited at most twice, achieving O(n) time complexity. Best approach uses two pointers with O(n) time and O(1) space.

Common Approaches

✓ Optimized

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

Binary Search on Answer

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

Use binary search to find the maximum achievable length. For each candidate length k, use sliding window to check if any substring of length k can be transformed within maxCost.

Brute Force

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

For each starting position, try all possible ending positions and calculate the cost to transform that substring. Keep track of the maximum length where cost ≤ maxCost.

Sliding Window

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

Maintain a window with left and right pointers. Expand right when cost ≤ maxCost, contract left when cost > maxCost. Track the maximum window size seen.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int getAverage(int** img, int imgSize, int* imgColSize, int x, int y) {
    int total = 0, count = 0;
    
    int startRow = (x > 0) ? x - 1 : 0;
    int endRow = (x < imgSize - 1) ? x + 1 : imgSize - 1;
    
    for (int i = startRow; i <= endRow; i++) {
        int startCol = (y > 0) ? y - 1 : 0;
        int endCol = (y < imgColSize[i] - 1) ? y + 1 : imgColSize[i] - 1;
        
        for (int j = startCol; j <= endCol; j++) {
            total += img[i][j];
            count++;
        }
    }
    
    return total / count;
}

int** solution(int** img, int imgSize, int* imgColSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = imgSize;
    *returnColumnSizes = (int*)malloc(imgSize * sizeof(int));
    
    int** result = (int**)malloc(imgSize * sizeof(int*));
    
    for (int i = 0; i < imgSize; i++) {
        (*returnColumnSizes)[i] = imgColSize[i];
        result[i] = (int*)malloc(imgColSize[i] * sizeof(int));
        
        for (int j = 0; j < imgColSize[i]; j++) {
            result[i][j] = getAverage(img, imgSize, imgColSize, i, j);
        }
    }
    
    return result;
}

int parseInt(char* str, int* pos) {
    while (str[*pos] && !isdigit(str[*pos]) && str[*pos] != '-') (*pos)++;
    if (!str[*pos]) return 0;
    
    int sign = 1;
    if (str[*pos] == '-') {
        sign = -1;
        (*pos)++;
    }
    
    int num = 0;
    while (str[*pos] && isdigit(str[*pos])) {
        num = num * 10 + (str[*pos] - '0');
        (*pos)++;
    }
    
    return sign * num;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse JSON array
    int pos = 0;
    while (input[pos] != '[') pos++; // Find first [
    pos++; // Skip [
    
    // Count rows
    int rows = 0;
    int tempPos = pos;
    while (input[tempPos]) {
        if (input[tempPos] == '[') rows++;
        tempPos++;
    }
    
    int** img = (int**)malloc(rows * sizeof(int*));
    int* imgColSize = (int*)malloc(rows * sizeof(int));
    
    for (int i = 0; i < rows; i++) {
        // Find start of row
        while (input[pos] != '[') pos++;
        pos++; // Skip [
        
        // Count columns in this row
        int cols = 0;
        int tempPos2 = pos;
        while (input[tempPos2] != ']') {
            if (isdigit(input[tempPos2]) || input[tempPos2] == '-') {
                cols++;
                while (input[tempPos2] && input[tempPos2] != ',' && input[tempPos2] != ']') tempPos2++;
            } else {
                tempPos2++;
            }
        }
        
        imgColSize[i] = cols;
        img[i] = (int*)malloc(cols * sizeof(int));
        
        // Parse numbers in this row
        for (int j = 0; j < cols; j++) {
            img[i][j] = parseInt(input, &pos);
        }
        
        // Skip to end of row
        while (input[pos] && input[pos] != ']') pos++;
        if (input[pos] == ']') pos++;
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(img, imgSize, imgColSize, &returnSize, &returnColumnSizes);
    
    // Print result
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < rows; i++) {
        free(img[i]);
        free(result[i]);
    }
    free(img);
    free(result);
    free(imgColSize);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

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