LeetCode: Substring with Concatenation of All Words 解题报告

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

SOLUTION 1:

1. 使用HashMap来保存L中所有的字串。

2. 暴力破解之。使用i记录我们的查找结果字符串的位置，j记录单个单词的查找位置。j每次移动一个L中单词的位置。

3. 注意各种越界条件：i查到离结束还有L*N（L中所有单词总长）的时候，即需要停止。

j 也要考虑每一次查找的单词的长度。

4. 使用第二个HashMap来记录我们查到的单词。如果所有的单词都查到了，即可记录一个解。

 // SOLUTION 1:
     public List<Integer> findSubstring1(String S, String[] L) {
         HashMap<String, Integer> map = new HashMap<String, Integer>();
         HashMap<String, Integer> found = new HashMap<String, Integer>();
         List<Integer> ret = new ArrayList<Integer>();

         if (S == null || L == null || L.length == 0) {
             return ret;
         }

         int cntL = 0;

         // put all the strings into the map.
         for (String s: L) {
             if (map.containsKey(s)) {
                 map.put(s, map.get(s) + 1);
             } else {
                 map.put(s, 1);
                 cntL++;
             }
         }

         int lenL = L[0].length();

         int cntFound = 0;

         // 注意这里的条件：i < S.length() - lenL * L.length
         // 这里很关键，如果长度不够了，不需要再继续查找
         for (int i = 0; i <= S.length() - lenL * L.length; i++) {
             // clear the found hashmap.
             found.clear();
             cntFound = 0;

             // 一次前进一个L的length.
             // 注意j <= S.length() - lenL; 防止越界
             for (int j = i; j <= S.length() - lenL; j += lenL) {
                 String sub = S.substring(j, j + lenL);
                 if (map.containsKey(sub)) {
                     if (found.containsKey(sub)) {
                         if (found.get(sub) == map.get(sub)) {
                             // 超过了限制数目
                             break;
                         }

                         found.put(sub, found.get(sub) + 1);
                     } else {
                         found.put(sub, 1);
                     }

                     if (found.get(sub) == map.get(sub)) {
                         cntFound++;
                     }

                     // L中所有的字符串都已经找到了。
                     if (cntFound == cntL) {
                         ret.add(i);
                     }
                 } else {
                     // 不符合条件，可以break,i前进到下一个匹配位置
                     break;
                 }
             }
         }

         return ret;
     }

12.26.2014 redo:

注意到几个容易出错的点：1. i的终止条件（用以防止TLE).  2. j的终止条件。

 public class Solution {
     public List<Integer> findSubstring(String S, String[] L) {
         ArrayList<Integer> ret = new ArrayList<Integer>();
         if (S == null || L == null || L.length == 0) {
             return ret;
         }

         HashMap<String, Integer> map = new HashMap<String, Integer>();
         HashMap<String, Integer> des = new HashMap<String, Integer>();

         for (String s: L) {
             if (map.containsKey(s)) {
                 map.put(s, map.get(s) + 1);
             } else {
                 // bug 1: should be , not .
                 map.put(s, 1);
             }
         }

         int wordLen = L[0].length();

         int size = L.length;
         int cnt = 0;

         int len = S.length();
         // bug 3: j <= len - wordLen * size to avoid the TLE
         for (int i = 0; i <= len - wordLen * size; i++) {
             // bug 2: should be des.clear not map.clear.
             des.clear();
             cnt = 0;

             // pay attention: should use j <= len.
             for (int j = i; j <= len - wordLen; j += wordLen) {
                 String sub = S.substring(j, j + wordLen);

                 if (!map.containsKey(sub)) {
                     break;
                 }

                 if (des.containsKey(sub)) {
                     des.put(sub, 1 + des.get(sub));
                 } else {
                     des.put(sub, 1);
                 }

                 if (des.get(sub) > map.get(sub)) {
                     break;
                 }

                 cnt++;

                 if (cnt == size) {
                     ret.add(i);
                     break;
                 }
             }
         }

         return ret;
     }
 }

SOLUTION 2:

1. 与解1相比，我们这次每次复制一个HashMap，找到一个单词，即减少此单词的计数，直到HashMap为空，表示我们找到一个解。

与Solution 1相比，这个方法写起来会简单一点。

 // SOLUTION 2:
     public List<Integer> findSubstring(String S, String[] L) {
         HashMap<String, Integer> map = new HashMap<String, Integer>();
         HashMap<String, Integer> found;
         List<Integer> ret = new ArrayList<Integer>();

         if (S == null || L == null || L.length == 0) {
             return ret;
         }

         // put all the strings into the map.
         for (String s: L) {
             if (map.containsKey(s)) {
                 map.put(s, map.get(s) + 1);
             } else {
                 map.put(s, 1);
             }
         }

         int lenL = L[0].length();

         // 注意这里的条件：i < S.length() - lenL * L.length
         // 这里很关键，如果长度不够了，不需要再继续查找
         for (int i = 0; i <= S.length() - lenL * L.length; i++) {
             // 每一次，都复制之前的hashMap.
             found = new HashMap<String, Integer>(map);

             // 一次前进一个L的length.
             // 注意j <= S.length() - lenL; 防止越界
             for (int j = i; j <= S.length() - lenL; j += lenL) {
                 String sub = S.substring(j, j + lenL);
                 if (found.containsKey(sub)) {
                     // 将找到字符串的计数器减1.
                     found.put(sub, found.get(sub) - 1);

                     // 减到0即可将其移出。否则会产生重复运算，以及我们用MAP为空来判断是否找到所有的单词。
                     if (found.get(sub) == 0) {
                         found.remove(sub);
                     }
                 } else {
                     // 不符合条件，可以break,i前进到下一个匹配位置
                     break;
                 }

                 // L中所有的字符串都已经找到了。
                 if (found.isEmpty()) {
                     ret.add(i);
                 }
             }
         }

         return ret;
     }

SOLUTION 3:

九章算法官网解：

http://www.ninechapter.com/solutions/substring-with-concatenation-of-all-words/

主页君GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/string/FindSubstring.java