LeetCode - Substring with Concatenation of All Words

Substring with Concatenation of All Words

2014.2.27 00:46

You are given a string, S, and a list of words, L, that are all of the same length. Find all starting indices of substring(s) in S that is a concatenation of each word in L exactly once and without any intervening characters.

For example, given:
S: "barfoothefoobarman"
L: ["foo", "bar"]

You should return the indices: [0,9].
(order does not matter).

Solution:

　　My solution to this problem is basically brute-force, starting from every position and check if a complete concatenation is possible.

　　<unordered_map> will provide efficient hashing.

　　Total time complexity is O(n^3). Space complexity is O(n).

Accepted code:

#include <string>
#include <unordered_map>
#include <vector>
using namespace std;

class Solution {
public:
    vector<int> findSubstring(string S, vector<string> &L) {
        vector<int> result_set;
        vector<int> vi;
        vector<int> vic;
        unordered_map<string, int> um;
        unordered_map<string, int>::iterator uit;
        int wl;
        int nc;
        int n = (int)L.size();
        int slen = (int)S.length();
        
        if (slen == 0 || n == 0) {
            return result_set;
        }
        wl = (int)L[0].length();
        if (wl == 0) {
            return result_set;
        }
        if (slen < n * wl) {
            return result_set;
        }
        
        um.clear();
        vi.clear();
        nc = 0;
        
        int i, j;
        for (i = 0; i < n; ++i) {
            uit = um.find(L[i]);
            if (uit == um.end()) {
                um[L[i]] = nc;
                vi.push_back(1);
                ++nc;
            } else {
                ++vi[um[L[i]]];
            }
        }
        vic.resize(nc);
        
        int cc, ll, rr;
        int idx;
        string str;
        
        for (i = 0; i < wl; ++i) {
            for (j = 0; j < nc; ++j) {
                vic[j] = vi[j];
            }
            cc = 0;
            
            ll = i;
            rr = ll;
            while (rr + wl <= slen) {
                str = S.substr(rr, wl);
                uit = um.find(str);
                if (uit != um.end()) {
                    idx = uit->second;
                    if (vic[idx] == 0) {
                        while (true) {
                            str = S.substr(ll, wl);
                            if (um[str] != idx) {
                                ll += wl;
                                ++vic[um[str]];
                                --cc;
                            } else {
                                ll += wl;
                                ++vic[um[str]];
                                --cc;
                                break;
                            }
                        }
                    } else {
                        --vic[idx];
                        ++cc;
                        rr += wl;
                    }
                } else {
                    ll = rr + wl;
                    for (j = 0; j < nc; ++j) {
                        vic[j] = vi[j];
                    }
                    rr = ll;
                    cc = 0;
                }
                if (cc == n) {
                    result_set.push_back(ll);
                    str = S.substr(ll, wl);
                    idx = um[str];
                    ++vic[idx];
                    --cc;
                    ll += wl;
                }
            }
        }
        vic.clear();
        
        return result_set;
    }
};