LeetCode //C - 30. Substring with Concatenation of All Words

30. Substring with Concatenation of All Words

You are given a string s and an array of strings words. All the strings of words are of the same length.

A concatenated substring in s is a substring that contains all the strings of any permutation of words concatenated.

• For example, if words = [“ab”,“cd”,“ef”], then “abcdef”, “abefcd”, “cdabef”, “cdefab”, “efabcd”, and “efcdab” are all concatenated strings. “acdbef” is not a concatenated substring because it is not the concatenation of any permutation of words.

Return the starting indices of all the concatenated substrings in s. You can return the answer in any order.

 

Example 1:

Input: s = “barfoothefoobarman”, words = [“foo”,“bar”]
Output: [0,9]
Explanation: Since words.length == 2 and words[i].length == 3, the concatenated substring has to be of length 6.
The substring starting at 0 is “barfoo”. It is the concatenation of [“bar”,“foo”] which is a permutation of words.
The substring starting at 9 is “foobar”. It is the concatenation of [“foo”,“bar”] which is a permutation of words.
The output order does not matter. Returning [9,0] is fine too.

Example 2:

Input: s = “wordgoodgoodgoodbestword”, words = [“word”,“good”,“best”,“word”]
Output: []
Explanation: Since words.length == 4 and words[i].length == 4, the concatenated substring has to be of length 16.
There is no substring of length 16 is s that is equal to the concatenation of any permutation of words.
We return an empty array.

Example 3:

Input: s = “barfoofoobarthefoobarman”, words = [“bar”,“foo”,“the”]
Output: [6,9,12]
Explanation: Since words.length == 3 and words[i].length == 3, the concatenated substring has to be of length 9.
The substring starting at 6 is “foobarthe”. It is the concatenation of [“foo”,“bar”,“the”] which is a permutation of words.
The substring starting at 9 is “barthefoo”. It is the concatenation of [“bar”,“the”,“foo”] which is a permutation of words.
The substring starting at 12 is “thefoobar”. It is the concatenation of [“the”,“foo”,“bar”] which is a permutation of words.

Constraints:

• $1<=s.length<=10^4$
• 1 <= words.length <= 5000
• 1 <= words[i].length <= 30
• s and words[i] consist of lowercase English letters.

From: LeetCode
Link: 30. Substring with Concatenation of All Words

---

Solution:

Ideas：

This solution uses a variant of the sliding window approach with two pointers, left and j. The idea is to move j forward to scan the string s, while adjusting left to ensure that the substring from left to j contains all the words in words[] with correct frequencies.

Here are the main steps:

1. Calculate the frequency of each word in words[] and store them in wordCounts[].

2. Iterate over the string s with a step size equal to the length of each word. For each i, it initializes a sliding window with left and j both pointing to i.

3. For each j, it extracts the substring s[j:j+wordLength] and checks if it is in words[]. If not, it resets left to j + wordLength, count to 0, and clears substringCounts[].

4. If the substring s[j:j+wordLength] is in words[], it increases the count of this word in substringCounts[]. If the count does not exceed that in wordCounts[], it increases count by 1. Otherwise, it moves left forward to make the count of this word in the window not exceed that in wordCounts[].

5. If the length of the window is equal to the total length of all words and count equals wordsSize, it means the window is a valid concatenated substring. It then adds the starting index left to the result array, and moves left forward by one word.

6. The function repeats this process for each possible starting index of a word. Finally, it returns all the starting indices of valid concatenated substrings.

Code:

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* findSubstring(char * s, char ** words, int wordsSize, int* returnSize) {
    // Create hash table for word frequencies
    int wordCounts[5000] = {0};
    int wordLength = strlen(words[0]);
    int totalLength = wordsSize * wordLength;
    int sLength = strlen(s);

    for (int i = 0; i < wordsSize; ++i) {
        for (int j = 0; j < wordsSize; ++j) {
            if (strcmp(words[i], words[j]) == 0) {
                ++wordCounts[i];
            }
        }
    }

    // Initialize result array
    int* result = (int*)malloc(sizeof(int) * sLength);
    *returnSize = 0;

    for (int i = 0; i < wordLength; ++i) {
        int left = i, count = 0;
        int substringCounts[5000] = {0};

        for (int j = i; j <= sLength - wordLength; j += wordLength) {
            char* substring = strndup(s + j, wordLength);

            int k;
            for (k = 0; k < wordsSize; ++k) {
                if (strcmp(substring, words[k]) == 0) {
                    ++substringCounts[k];
                    if (substringCounts[k] <= wordCounts[k]) {
                        ++count;
                    } else {
                        while (substringCounts[k] > wordCounts[k]) {
                            char* leftSubstring = strndup(s + left, wordLength);
                            for (int l = 0; l < wordsSize; ++l) {
                                if (strcmp(leftSubstring, words[l]) == 0) {
                                    --substringCounts[l];
                                    if (substringCounts[l] < wordCounts[l]) {
                                        --count;
                                    }
                                    break;
                                }
                            }
                            free(leftSubstring);
                            left += wordLength;
                        }
                    }
                    break;
                }
            }

            free(substring);

            if (k == wordsSize) {
                memset(substringCounts, 0, sizeof(substringCounts));
                count = 0;
                left = j + wordLength;
            } else if (j + wordLength - left == totalLength && count == wordsSize) {
                result[(*returnSize)++] = left;
                char* leftSubstring = strndup(s + left, wordLength);
                for (int l = 0; l < wordsSize; ++l) {
                    if (strcmp(leftSubstring, words[l]) == 0) {
                        --substringCounts[l];
                        --count;
                        break;
                    }
                }
                free(leftSubstring);
                left += wordLength;
            }
        }
    }

    return result;
}