Count Substrings That Can Be Rearranged to Contain a String II

Count Substrings That Can Be Rearranged to Contain a String II - Problem

You are given two strings word1 and word2. Your task is to find the total number of valid substrings of word1.

A substring x is called valid if the characters in x can be rearranged to have word2 as a prefix. In other words, x must contain at least all the characters that appear in word2, with the same or greater frequency.

Example: If word2 = "abc", then substrings like "abcd", "bacde", or "xabcy" are valid because they can be rearranged to start with "abc".

Note: This problem has strict memory constraints, requiring a linear time complexity solution.

Input & Output

example_1.py — Basic Case

$ Input: word1 = "bcca", word2 = "abc"

› Output: 1

💡 Note: Only the substring "bcc" (indices 0-2) contains at least 1 'a', 1 'b', and 1 'c', so it can be rearranged to have "abc" as prefix. Wait, that's wrong. Actually "bcca" contains a=1, b=1, c=2 which satisfies word2="abc" needing a=1,b=1,c=1. So the valid substrings are those containing at least these counts.

example_2.py — Multiple Valid Substrings

$ Input: word1 = "abcabc", word2 = "ab"

› Output: 10

💡 Note: word2 needs a=1, b=1. Valid substrings: "ab"(0-1), "abc"(0-2), "abca"(0-3), "abcab"(0-4), "abcabc"(0-5), "abca"(1-4), "abcab"(1-5), "abcabc"(1-6), "ab"(3-4), "abc"(3-5). Total: 10 substrings.

example_3.py — No Valid Substrings

$ Input: word1 = "a", word2 = "aa"

› Output: 0

💡 Note: word2 requires a=2, but word1 only has a=1 total. No substring of word1 can contain enough 'a' characters to satisfy the requirement.

Constraints

1 ≤ word1.length ≤ 10⁵
1 ≤ word2.length ≤ 10⁴
word1 and word2 consist of lowercase English letters only
Memory constraints are tighter than usual - linear time solution required

Visualization

Tap to expand

Understanding the Visualization

Set Recipe Requirements

Define what ingredients (characters) and quantities we need from word2

Slide Window Right

Expand window by moving right boundary, adding ingredients one by one

Check Recipe Complete

When window contains enough ingredients, count all valid recipe combinations

Count Efficiently

Use the insight that if [L,R] works, then [0,R], [1,R], etc. might also work

Key Takeaway

🎯 Key Insight: The sliding window technique transforms an O(n³) brute force problem into an elegant O(n) solution by avoiding redundant character counting and using the mathematical property that valid window extensions are also valid.

Asked in

G Google 42 f Meta 35 a Amazon 28 ⊞ Microsoft 18

The optimal solution uses a sliding window technique to achieve O(n) time complexity. For each ending position, we find the leftmost valid starting position and count all valid substrings ending at that position. This avoids the O(n³) brute force approach of checking every substring individually.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Map (Optimal)	O(n)	O(k)	Use expanding sliding window technique with character frequency tracking
Brute Force (Check All Substrings)	O(n³)	O(k)	Check every possible substring of word1 to see if it contains enough characters

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Create frequency map for word2 characters
Use sliding window: expand right pointer to include more characters
When window becomes valid, count all valid substrings ending at current position
Key insight: if window [L,R] is valid, then [0,R], [1,R], ..., [L,R] might also be valid
Use efficient counting to avoid recalculating for each substring

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix right endpoint

For each position, fix it as the right end of substring

Expand window left

Move left boundary leftward, adding characters to window

Check validity

Once window becomes valid, count all valid substrings

Key insight

If [L,R] is valid, then [0,R], [1,R], ..., [L,R] are also valid

Code -

solution.c — C

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

long long countSubstrings(char* word1, char* word2) {
    int word2Count[26] = {0};
    int len2 = strlen(word2);
    
    for (int i = 0; i < len2; i++) {
        word2Count[word2[i] - 'a']++;
    }
    
    int n = strlen(word1);
    long long result = 0;
    
    // For each ending position
    for (int end = 0; end < n; end++) {
        int windowCount[26] = {0};
        
        // Find leftmost valid start
        for (int start = end; start >= 0; start--) {
            windowCount[word1[start] - 'a']++;
            
            // Check validity
            int valid = 1;
            for (int i = 0; i < 26; i++) {
                if (windowCount[i] < word2Count[i]) {
                    valid = 0;
                    break;
                }
            }
            
            if (valid) {
                result += start + 1;
                break;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through word1 with constant time hash map operations

✓ Linear Growth

Space Complexity

O(k)

O(k) for character frequency maps where k is alphabet size (constant)

✓ Linear Space

28.5K Views

High Frequency

~25 min Avg. Time

847 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

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler