[leetcode]Substring with Concatenation of All Words

代码写的很乱。参考的思路和昨天的Minimum Window Substring有类似。参考的文章是：http://discuss.leetcode.com/questions/210/substring-with-concatenation-of-all-words

代码里还特意把字符串转成数字id用来简化，这个优化不是必须的，没有的话代码会简单点。

一开始是用字典计数，然后穷举。后来时间不过，就只能用Min Window类似的双指针扫描的思路优化，保证一遍下来。差不多是O(n)的复杂度。

又看了一下我和参考中代码的区别，由于受到昨天的影响，我还在计算每个字符（串）超出的情况，其实现在只要记录全部的字符串数n就行了，维持一个窗口，因为肯定是连续的，这样代码可以简化许多。

我的代码：

import java.util.ArrayList;
import java.util.HashMap;

public class Solution {
public ArrayList<Integer> findSubstring(String S, String[] L) {
// Start typing your Java solution below
// DO NOT write main() function
ArrayList<Integer> ret = new ArrayList<Integer>();
if (L.length == 0) return ret;

HashMap<String, Integer> ids = new HashMap<String, Integer>();
HashMap<Integer, Integer> neededCount = new HashMap<Integer, Integer>();

int len = L[0].length();
int[] LL = new int[S.length() - len + 1];

// convert S to LL
for (int i = 0; i+len <= S.length(); i++) {
String s = S.substring(i, i+len);
if (!ids.containsKey(s)) {
int id = ids.size() + 1;
ids.put(s, id);
}
int id = ids.get(s);
LL[i] = id;
}

// init neededCount
for (int i = 0; i < L.length; i++) {
if (!ids.containsKey(L[i])) {
return ret;
}
int id = ids.get(L[i]);
if (neededCount.containsKey(id)) {
int c = neededCount.get(id);
neededCount.put(id, c+1);
}
else {
neededCount.put(id,  1);
}
}

HashMap<Integer, Integer> currentCount = new HashMap<Integer, Integer>();
for (int i = 0; i < len; i++) {
currentCount.clear();
int total = 0;

int left = i;
int right = left;
while (right < LL.length) {
int id = LL[right];
if (!neededCount.containsKey(id)) {
right += len;
left = right;
currentCount.clear();
total = 0;
continue;
}
if (!currentCount.containsKey(id)) {
currentCount.put(id, 1);
}
else {
int c = currentCount.get(id);
if (c >= neededCount.get(id)) { // ==
// move left forward
while (left <= right) {
if (LL[left] == id) {
currentCount.put(id, c-1);
total--;
left += len;
break;
}
left += len;
}
if (left > right) {
right += len;
left = right;
currentCount.clear();
total = 0;
continue;
}
}
c = currentCount.get(id);
currentCount.put(id, c+1);
}

total++;
if (total == L.length) {
ret.add(left);
// move left forward
int l = LL[left];
int c = currentCount.get(l);
currentCount.put(l, c-1);
total--;
left += len;

}
right+=len;
}
}
return ret;
}
}

参考代码：

class Solution {
public:
vector<int> findSubstring(string S, vector<string> &L) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
int m = S.size(), n = L.size(), len = L[0].size();
map<string, int> ids;

vector<int> need(n, 0);
for (int i = 0; i < n; ++i) {
if (!ids.count(L[i])) ids[L[i]] = i;
need[ids[L[i]]]++;
}

vector<int> s(m, -1);
for (int i = 0; i < m - len + 1; ++i) {
string key = S.substr(i, len);
s[i] = ids.count(key) ? ids[key] : -1;
}

vector<int> ret;
for (int offset = 0; offset < len; ++offset) {
vector<int> found(n, 0);
int count = 0, begin = offset;
for (int i = offset; i < m - len + 1; i += len) {
if (s[i] < 0) {
// recount
begin = i + len;
count = 0;
found.clear();
found.resize(n, 0);
} else {
int id = s[i];
found[id]++;
if (need[id] && found[id] <= need[id])
count++;

if (count == n)
ret.push_back(begin);

// move current window
if ((i - begin) / len + 1 == n) {
id = s[begin];
if (need[id] && found[id] == need[id])
count--;
found[id]--;
begin += len;
}
}
}
}
return ret;
}
};