My code:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Solution {
public List<Integer> findSubstring(String s, String[] words) {
ArrayList<Integer> ret = new ArrayList<Integer>();
if (s == null || s.length() == 0 || words == null || words.length == 0)
return ret;
HashMap<String, Integer> check = new HashMap<String, Integer>();
int unitLen = words[0].length();
for (int i = 0; i < words.length; i++) {
if (!check.containsKey(words[i])) {
check.put(words[i], 1);
}
else {
int times = check.get(words[i]);
check.put(words[i], times + 1);
}
}
for (int i = 0; i <= s.length() - unitLen * words.length; i++) {
if (helper(i, words, check, s.substring(i, i + unitLen * words.length)))
ret.add(i);
}
return ret;
}
private boolean helper(int begin, String[] words, HashMap<String, Integer> check, String s) {
HashMap<String, Integer> cmp = new HashMap<String, Integer>();
int unitLen = words[0].length();
for (int i = 0; i < words.length; i++) {
String tmp = s.substring(unitLen * i, unitLen * (i + 1));
if (!cmp.containsKey(tmp)) {
cmp.put(tmp, 1);
}
else {
int times = cmp.get(tmp);
cmp.put(tmp, times + 1);
}
if (check.get(tmp) == null || cmp.get(tmp) > check.get(tmp))
return false;
}
return true;
}
public static void main(String[] args) {
Solution test = new Solution();
String s = "barfoothefoobarman";
String[] words = {"foo", "bar"};
System.out.println(test.findSubstring(s, words));
}
}
這道題目一開始我的實現方式不是這樣的。順序反了，導致時間測試總是過不了。然后網上看了提示才寫了出來。
好久沒刷題，感覺那種做題的感覺已經消耗光了。沒事，慢慢來吧。
這道題目第一感覺肯定是用HashMap。
但是，在以誰為原型，放入hashmap中，我卻犯了錯誤。
我把 string s 作為原型放入哈希表中。導致每次換一個起始位置時都要重構哈希表。浪費了大量的操作。我的做法相當于是把s存起來。然后拿words來和s比較。
但反一反，會更加的簡潔。
也就是說，我把words存在一個哈希表中，拿s去進行比較。這樣我的哈希表就不用每次都重構了。因為words是永恒不變的。
然后還有個小技巧，幫助words的哈希表永恒不變。
當我的比較字符串是s時，按道理，我會把拆成一塊塊。然后對words的哈希表進行移除操作。如果最后哈希表正好全部光了，那么，一定是對的。但是這樣就會改變words，和我以前的做法，沒什么差別。那么如何不改變words呢？
新建一個哈希表，對s建立這個哈希表。然后如果某塊substring 在 words對應的哈希表中沒有出現，
或者在words對應的哈希表中出現的次數更少，那么就是錯的。
遍歷結束后再返回true。
基本思路就是這樣了。
感覺自己的思維還是很不對。而且以前的感覺也沒了。現在看到題目腦子會犯渾。而且再怎么簡單的題目，也很難一次做對。這個要注意改正。
**
總結： hash table
**
Anyway, Good luck, Richardo!
My code:
public class Solution {
public List<Integer> findSubstring(String s, String[] words) {
ArrayList<Integer> ret = new ArrayList<Integer>();
if (s == null || s.length() == 0 || words == null || words.length == 0)
return ret;
int len = words[0].length(); // record the length of one word
/** track the number of strings in words[] */
HashMap<String, Integer> tracker = new HashMap<String, Integer>();
for (int i = 0; i < words.length; i++) {
if (!tracker.containsKey(words[i])) {
tracker.put(words[i], 1);
}
else {
int times = tracker.get(words[i]);
tracker.put(words[i], times + 1);
}
}
int i = 0;
while (i <= s.length() - words.length * len) {
helper(i, tracker, words, s, ret);
i++;
}
return ret;
}
private void helper(int begin, HashMap<String, Integer> tracker, String[] words,
String s, ArrayList<Integer> ret) {
int len = words[0].length(); // record the length of one word
HashMap<String, Integer> copy = new HashMap<String, Integer>();
int i = begin;
while (i < begin + len * words.length) { // [begin, begin + len * words.length)
String curr = s.substring(i, i + len);
if (!tracker.containsKey(curr))
return;
else if (!copy.containsKey(curr)) {
copy.put(curr, 1);
}
else {
int times = copy.get(curr);
if (times + 1 > tracker.get(curr))
return;
else
copy.put(curr, times + 1);
}
i += len;
}
ret.add(begin);
}
}
自己寫了出來，但是一看時間測試不對，比較慢。后來查了答案，才知道還有一種更優化的解法，也是這道題木，真正的考點，意義。
sliding window
然后我重寫了如下：
My code:
public class Solution {
public List<Integer> findSubstring(String s, String[] words) {
ArrayList<Integer> ret = new ArrayList<Integer>();
if (s == null || s.length() == 0 || words == null || words.length == 0)
return ret;
int len = words[0].length(); // record the length of one word
/** track the number of strings in words[] */
HashMap<String, Integer> tracker = new HashMap<String, Integer>();
for (int i = 0; i < words.length; i++) {
if (!tracker.containsKey(words[i])) {
tracker.put(words[i], 1);
}
else {
int times = tracker.get(words[i]);
tracker.put(words[i], times + 1);
}
}
for (int i = 0; i < len; i++) {
int start = i;
HashMap<String, Integer> cmp = new HashMap<String, Integer>();
int counter = 0;
for (int j = i; j <= s.length() - len; j += len) { // window: [start, start len), keep moving left
String curr = s.substring(j, j + len);
if (tracker.containsKey(curr)) {
if (!cmp.containsKey(curr))
cmp.put(curr, 1);
else {
cmp.put(curr, cmp.get(curr) + 1);
}
counter++;
while (cmp.get(curr) > tracker.get(curr)) {
String pre = s.substring(start, start + len);
cmp.put(pre, cmp.get(pre) - 1);
start = start + len;
counter--;
}
if (counter == words.length) {
ret.add(start);
String pre = s.substring(start, start + len);
cmp.put(pre, cmp.get(pre) - 1);
counter--;
start += len;
}
}
else {
cmp.clear();
start = j + len;
counter = 0;
}
}
}
return ret;
}
}
這道題木的思想是，第一層循環，就遍歷， [o, len)
然后每一個循環，都是以len為單位得跳。
比如我已經檢測了 [start, j + len), 這一塊，
此時，如果發現
[j, j + len) 不存在于s中，直接清空哈希表cmp，counter = 0,然后讓start指向 j + len,
[start, j + len) 不可能是組成最終結果的其中一部分了，因為有[j, j + len) 的存在。
如果存在于s中，counter++
如果該字符串出現次數已經大于words限定了。那么在[start, j + len) 中，一定存在一個多余出來的該字符串。在該字符串前的其他字符，不會是構成最終結果的一部分。
于是開始用sliding window，一個窗口一個窗口的減，直到發現某個時刻，該字符串出現次數正常了，就退出循環。
用sliding window 做真的是節約了資源。
參考網頁：
http://www.programcreek.com/2013/02/longest-substring-which-contains-2-unique-characters/
然后對應的一道谷歌的衍生題木，很類似。
http://www.programcreek.com/2013/02/longest-substring-which-contains-2-unique-characters/
看來這個思想還是很重要的。也是我今天第一次接觸。好好記住了！
Anyway, Good luck, Richardo!
