Leetcode_substring-with-concatenation-of-all-words

地址： http://oj.leetcode.com/problems/substring-with-concatenation-of-all-words/

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).

思路：这道题应该用map来解决，因为要快速的查找字符串。这里还要用到两个map，应该要重复计数，应尽量减少对map的大规模操作，比如复制。

另外要记住map的一个地方是，当map中不存在某个key-value时，用[]的操作去访问key，即map[key]，map会自动创建一个默认的key-value pair插入到map中。笔者记得这一点在c++ primer上讲过。而如果value类型是int的，默认值恰是0.这一点可以实际编程来调试查看。

参考代码：1756ms

class Solution {
public:
    vector<int> findSubstring(string S, vector<string> &L) {
        vector<int>ans;
        if(S.empty() || L.empty())
            return ans;
        int one_word_len = L[0].length();
        map<string, int>dm, tmpm;
        for(int i = 0; i<L.size(); ++i)
            dm[L[i]] = dm[L[i]]==0 ? 1 : dm[L[i]]+1;
        
        for(int i = 0; i + one_word_len*L.size() <= S.length(); ++i)
        {
            int j = 0;
            tmpm.clear();
            for(; j < L.size(); ++j)
            {
                string str = S.substr(i+j*one_word_len, one_word_len);
                if(dm.find(str)!=dm.end() && tmpm[str]<dm[str])
                {
                    ++tmpm[str];
                }
                else
                {
                    break;
                }
            }
            if(j==L.size())
                ans.push_back(i);
        }
        return ans;
    }
};

下面一个代码就TLE了，因为多次对map进行了不必要的复制操作。看来清空map总比复制map节约时间的。

TLE代码：

class Solution {
public:
    vector<int> findSubstring(string S, vector<string> &L) {
        vector<int>ans;
        if(S.empty() || L.empty())
            return ans;
        int one_word_len = L[0].length();
        map<string, int>dm, backup;
        for(int i = 0; i<L.size(); ++i)
            dm[L[i]] = dm[L[i]]==0 ? 1 : dm[L[i]]+1;
        backup = dm;
        for(int i = 0; i + one_word_len*L.size() <= S.length(); ++i)
        {
            int j = 0;
            for(; j < L.size(); ++j)
            {
                string str = S.substr(i+j*one_word_len, one_word_len);
                if(dm.find(str)!=dm.end() && dm[str])
                {
                    --dm[str];
                }
                else
                {
                    dm = backup;
                    break;
                }
            }
            if(j==L.size())
                ans.push_back(i);
        }
        return ans;
    }
};