Match Substring After Replacement

Match Substring After Replacement - Problem

You are given two strings s and sub. You are also given a 2D character array mappings where mappings[i] = [old_i, new_i] indicates that you may perform the following operation any number of times:

Replace a character old_i of sub with new_i.

Each character in sub cannot be replaced more than once.

Return true if it is possible to make sub a substring of s by replacing zero or more characters according to mappings. Otherwise, return false.

A substring is a contiguous non-empty sequence of characters within a string.

Input & Output

Example 1 — Basic Match with Replacement

$ Input: s = "fool3e7bar", sub = "leet", mappings = [["e","3"],["t","7"],["t","8"]]

› Output: true

💡 Note: At position 2: "ol3e" matches "leet" by replacing e→3 in sub, giving "le37" which doesn't work. At position 2: we need to match s[2:6]="ol3e" with sub="leet". We can replace 'e'→'3' and 't'→'7' to get "le37", but this doesn't match "ol3e". Actually, at position 2: s="ool3" vs sub="leet" - this doesn't work. Let me recalculate: we need s[i:i+4] to match sub after replacements.

Example 2 — No Valid Match

$ Input: s = "fooleetbar", sub = "f00", mappings = [["o","0"]]

› Output: false

💡 Note: No position in s matches sub="f00" after applying mappings. At position 0: "foo" vs "f00" - 'f' matches 'f', but 'o' cannot be mapped to '0' (we need '0'→'o' mapping but only have 'o'→'0'). The mapping allows replacing 'o' in sub with '0', but sub already has '0' characters that need to become 'o' to match s.

Example 3 — Exact Match

$ Input: s = "abcd", sub = "bc", mappings = []

› Output: true

💡 Note: At position 1: "bc" in s exactly matches sub "bc" without any replacements needed.

Constraints

1 ≤ sub.length ≤ s.length ≤ 5000
0 ≤ mappings.length ≤ 1000
mappings[i].length == 2
s and sub consist of lowercase English letters and digits
mappings[i] consists of lowercase English letters

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 a Amazon 8

The key insight is to check each position in string s to see if sub can match using character mappings. The hash map approach is optimal, preprocessing mappings for O(1) lookup. Time: O(n×m + k), Space: O(k) where n=|s|, m=|sub|, k=|mappings|.

Common Approaches

✓ Dp 1d

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

Brute Force - Try All Positions

⏱️ Time: O(n × m × k) Space: O(1)

For each position in s, try to match sub character by character. For each character mismatch, check if there's a mapping that can transform the sub character to match the s character.

Hash Map Optimization

⏱️ Time: O(n × m + k) Space: O(k)

Build a hash map of character mappings once, then for each position in s, check if sub can match using the precomputed mappings for efficient lookup.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

long long solution(int* nums, int n) {
    if (n == 1) return nums[0];
    
    // dp[i] represents maximum cost for first i elements
    long long* dp = (long long*)malloc((n + 1) * sizeof(long long));
    for (int i = 0; i <= n; i++) {
        dp[i] = LLONG_MIN;
    }
    dp[0] = 0;
    
    for (int i = 1; i <= n; i++) {
        // Try all possible starting positions for subarray ending at i-1
        for (int j = 0; j < i; j++) {
            // Calculate cost of subarray from j to i-1
            long long cost = 0;
            for (int k = j; k < i; k++) {
                int sign = (k - j) % 2 == 0 ? 1 : -1;
                cost += sign * nums[k];
            }
            if (dp[j] + cost > dp[i]) {
                dp[i] = dp[j] + cost;
            }
        }
    }
    
    long long result = dp[n];
    free(dp);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium 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