3. 无重复字符的最长子串
A：
要找最长的无重复子串，所以用一个map保存出现过的字符，并且维持一个窗口，用le和ri指针标识。ri为当前要遍历的字符，如果ri字符在map中出现过，那么将le字符从map移除，le++。如果ri字符没出现过，那ri++，并更新最大无重复子串长度。全程利用map保持无重复的要求，每次循环要么le++，要么ri++。最差情况是n个一样的字符，那么ri++，le++，ri++，le++这样一直从0循环到n-1。时间复杂度和空间复杂度都是O(N)。
class Solution {
public:
int lengthOfLongestSubstring(string s) {
if(s.empty()){return 0;}
int le=0,ri=1;
map<char,int> dic;
dic[s[0]]+=1;
int max_len=1;
while(ri<s.size()){
if(dic[s[ri]]){
dic[s[le]]-=1;
++le;
}
else{
dic[s[ri]]+=1;
++ri;
max_len=max(max_len,ri-le);
}
}
return max_len;
}
};
30. 串联所有单词的子串
A：
题目指定了所有单词是一样长度的，那么我们就可以按单词为单位进行查找。假如单词长度为3，那么从0、1、2分别按单词长度进行查找，一直查找到字符串结尾，就可以查找到所有满足条件的子串。
class Solution {
public:
vector<int> findSubstring(string s, vector<string>& words) {
if(s.empty() or words.empty()){
return vector<int>();
}
int s_len=s.length(),one_word=words[0].size(),all_word=words.size()*one_word,word_cnt=words.size();
if(all_word>s_len){
return vector<int>();
}
map<string,int> dic;
for(const string& word:words){
dic[word]+=1;
}
vector<int> res;
for(int i=0;i<one_word;++i){
int le=i,ri=i,cnt=0;
map<string,int> cur_dic;
while(ri+one_word-1<s_len){ //ri开头的单词结尾不能越界
string cur=s.substr(ri,one_word); //当前单词
if(dic[cur]==0){ //无匹配
ri+=one_word;
le=ri;
cnt=0;
cur_dic.clear();
}
else{ //匹配
ri+=one_word;
cur_dic[cur]+=1;
++cnt;
while(dic[cur]<cur_dic[cur]){
string w=s.substr(le,one_word);
cur_dic[w]-=1;
le+=one_word;
--cnt;
}
if(cnt==word_cnt){
res.push_back(le);
}
}
}
}
return res;
}
};
但是稍微改动一下：
class Solution {
public:
vector<int> findSubstring(string s, vector<string>& words) {
if(s.empty() or words.empty()){
return vector<int>();
}
int s_len=s.length(),one_word=words[0].size(),all_word=words.size()*one_word,word_cnt=words.size();
if(all_word>s_len){
return vector<int>();
}
map<string,int> dic;
for(const string& word:words){
dic[word]+=1;
}
vector<int> res;
for(int i=0;i<one_word;++i){
int le=i,ri=i,cnt=0;
unordered_map<string,int> cur_dic;
while(ri+one_word-1<s_len){ //ri开头的单词结尾不能越界
string cur=s.substr(ri,one_word); //当前单词
if(dic.count(cur) and cur_dic[cur]<dic[cur]){
++cnt;
cur_dic[cur]+=1;
ri+=one_word;
}
else{
if(dic.count(cur)==0){ //ri开头的单词不在单词表里
ri+=one_word; //ri后移一个单词长度
if(ri+one_word-1>=s_len){
break;
}
//因为之前ri开头的单词gg了，那么移动le到新的ri重新开始
le=ri;
cur_dic.clear();
cnt=0;
}
else{ //cur_dic[cur]>=dic[cur]，le一直右移直到cur_dic[cur]<dic[cur]使得cur能插入
while(cur_dic[cur]>=dic[cur]){
cur_dic[s.substr(le,one_word)]-=1;
le+=one_word;
--cnt;
}
}
}
if(cnt==word_cnt){
res.push_back(le);
cur_dic[s.substr(le,one_word)]-=1;
le+=one_word;
--cnt;
}
}
}
return res;
}
};
改动的地方只是把dic[cur]==0改成了dic.count(cur)==0。对于dic中不存在的cur，前者会自动假如加入 dic，默认值为0。所以内存用量一下从14M变成了26M，同时map的查询时间是log级别，所有的查map时间也会有相应增加，这一点一定要注意。
76. 最小覆盖子串
A:
写了两遍，代码基本的结构一致，唯一一点区别是第一种是先一直向右寻找直到找到覆盖t的子串，再尽量把左边界右移加入结果。
第二种是每次循环只向右跳一个字符，如果还没找到覆盖t的子串就记录并把左边界尽量右移，找到的话就加入结果。其实写到这我发现这俩解法没啥区别，就不说了吧。
另外看见题解里有一种解法是把s串中属于t串的字符挑出来记录成map，这样在遍历s寻找覆盖t的子串的时候就不用实际在s中从0到s.size()-1慢慢挪了，相当于把不属于t串的字符直接一下子跳过。在s串长度远大于t的时候能节省大量时间，这个写法有时间再补吧。。2019年11月13日 22:19:10
class Solution {
public:
string minWindow(string s, string t) {
if(s.empty() or t.empty()){
return string();
}
map<char,int> dic,cur_dic;
for(const char& c:t){
dic[c]+=1;
}
int le=0,ri=0,min_len=INT_MAX,cnt=0,t_len=t.size();
string res="";
while(ri<s.size()){
// cout<<le<<" "<<ri<<" "<<s.substr(le,ri-le)<<" "<<cnt<<endl;
while(ri<s.size() and cnt<t_len){
if(dic.count(s[ri])>0){
if(dic[s[ri]]>cur_dic[s[ri]]){
cnt++;
}
cur_dic[s[ri]]++;
}
++ri;
}
if(cnt!=t_len){
return res;
}
while(dic.count(s[le])==0 or dic[s[le]]<cur_dic[s[le]]){
if(dic.count(s[le])!=0){
cur_dic[s[le]]--;
}
++le;
}
if(ri-le<min_len){
min_len=ri-le;
res=s.substr(le,ri-le);
}
cur_dic[s[le]]--;
++le;
cnt--;
}
return res;
}
};
class Solution {
public:
string minWindow(string s, string t) {
if(s.empty() or t.empty()){
return string();
}
map<char,int> dic,cur_dic;
for(const char& c:t){
dic[c]+=1;
}
int le=0,ri=0,min_len=INT_MAX,cnt=0,t_len=t.size();
string res="";
while(ri<=s.size()){
// cout<<le<<" "<<ri<<" "<<s.substr(le,ri-le)<<" "<<cnt<<endl;
char c=s[ri];
++ri;
if(dic.count(c)){ //匹配
cur_dic[c]+=1;
if(dic[c]>=cur_dic[c]){
++cnt;
}
while(1){ //有重复匹配的，一直右移左边界
while(dic.count(s[le])==0){ //跳过开头多余字符
++le;
}
if(dic[s[le]]<cur_dic[s[le]]){
cur_dic[s[le]]-=1;
++le;
}
else{
break;
}
}
while(dic.count(s[le])==0){
++le;
}
if(cnt==t_len and ri-le<min_len){
cout<<s.substr(le,ri-le)<<endl;
min_len=ri-le;
res=s.substr(le,ri-le);
}
}
else{ //不匹配
;
}
}
return res;
}
};
可以看到两种解法时间并不算快，因为是遍历了s的全部字符。
159. 至多包含两个不同字符的最长子串
class Solution {
public:
int lengthOfLongestSubstringTwoDistinct(string s) {
map<char,int>dic;
int le=0,ri=0,cnt=0,s_len=s.size(),max_len=0;
while(ri<s_len){
if(cnt==2){
if(dic.count(s[ri])){ //是之前的两个字符之一，直接添加
dic[s[ri]]++;
++ri;
}
else{ //不属于之前的两个字符
while(dic[s[le]]>1){ //找最左侧元素出现次数为1的
dic[s[le]]-=1;
++le;
}
dic.erase(s[le++]); //把这个出现次数为1的删了
dic[s[ri]]++;
++ri;
}
}
else{ //cnt=0 or 1
if(dic.count(s[ri])==0){
++cnt;
}
dic[s[ri++]]+=1;
}
max_len=max(max_len,ri-le);
}
return max_len;
}
};
209. 长度最小的子数组
这题不解释了阿，前面会了就会。
A:
class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums) {
int le=0,ri=0,len=nums.size(),min_len=INT_MAX,cur_sum=0;
while(ri<len){
cur_sum+=nums[ri++];
if(cur_sum>=s){
while(cur_sum-nums[le]>=s){
cur_sum-=nums[le];
++le;
}
min_len=min(min_len,ri-le);
}
}
return min_len!=INT_MAX?min_len:0;
}
};
239. 滑动窗口最大值
这题没做出来，用的是一个新的东西：双端队列。
我先说一下我做时候的想法：由于这题的窗口是固定长度，每次要找窗口内的最大值。那最naive的方法就是维护长度k的窗口，遍历(n-k)*k次就行，复杂度O(nk)。然后我又考虑可以用堆（c++优先队列）维护窗口，这样复杂度可以减少为O(nlogk)。但问题是假如前一个窗口的最大值是首元素，窗口后移一位后，怎么把之前最大值删掉。更新：这里可以用索引堆，专门去研究了一下索引堆怎么写。 但这个写法就不写了。
下面只放一个双端队列的做法：
思路是维护一个双端队列（两边都可以push和pop的队列），其大小为k。然后关键要始终维持的性质是该队列为非递减序，即x1<=x2<=x3<=…<=xk。当然比如k=4，数组前4个数是1、5、2、6，那么首先插入1，接下来5>=1故插入，2<=5故pop5，剩下1，插入2，此时队列中为1、2。接下来6>=2，插入6。最后队列中就是1、2、6。但这里我们队列不存储值，而是存储对应nums数组中的下标。如之前1、2、6对应我们存储的是0、2、3。然后每次窗口右移一位，每次要考察队首（队列左侧）的值是否已经越界。即当前窗口右侧到达i位置，那么最左侧位置不能小于i+1-k，否则整个窗口长度就超过k了，这就不符题意了。而且每次滑动窗口只需要检验最左侧，原因有二：1. 我们push索引到窗口里的时候是从左到右遍历nums来的，故只要最左侧不越界，窗口其它位置一定不越界。2. 由于滑动窗口一次只挪一位。
上面一段写成代码就是：
if(!window.empty() and window.front()<i-k+1){
window.pop_front();
}
考察最左侧索引后，剩下的工作就是push新移进窗口的右边界（新的边界）。
同最开始建立初始窗口一样，我们要保持非降序。小于右边界的都pop，最后把右边界push进来，就完成了一轮窗口的移动。对应的代码如下：
while(!window.empty() and nums[window.back()]<nums[i]){
window.pop_back();
}
window.push_back(i);
这样完成一轮移动后，窗口内最大的元素就是左边界作为索引p对应的nums中的元素nums[p]。
下面我简单证明一下这个算法的有效性。
1.对于任意长度k的子数组，我们对左边界是否越界的考察保证了当前窗口不会包含比该长度k子数组更多的元素。
2.既然我们的窗口包含元素比实际长度k的子数组更少，那有没有可能会略掉某个该子数组中的最大值没有统计呢？假设实际子数组是i到i+k-1，那么上次的窗口遍历的是i-1到i+k-2的子数组，并假设上次的窗口window1中的元素都满足不越界（相当于数学归纳法，假设i-1的情况成立，只要推得i的情况成立，并且i==1时情况成立结论就成立，而这题我们第一轮初始的窗口显然是正确的）。1. 假设上次的窗口是window1。若window1包含i-1，则当前这轮遍历开始时，会考察左边界是否越界，此时会把i-1剔除掉，再push进来i+k-1号。故这种情况当前窗口会输出正确结果。
2. 假设上次的窗口window1不包含i-1，那么显然这轮遍历开始时，左边界肯定不会越界，因为左边界最多也就是i，i本来就应该在当前窗口内的。故这种情况也会输出正确结果。
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
if(k<1 or nums.empty()){
return vector<int>();
}
deque<int> window;
int siz=nums.size();
vector<int> res;
//初始化双端队列
for(int i=0;i<k;++i){
while(!window.empty() and nums[window.back()]<nums[i]){
window.pop_back();
}
window.push_back(i);
}
res.push_back(nums[window.front()]);
for(int i=k;i<siz;++i){
if(!window.empty() and window.front()<i-k+1){
window.pop_front();
}
while(!window.empty() and nums[window.back()]<nums[i]){
window.pop_back();
}
window.push_back(i);
res.push_back(nums[window.front()]);
}
return res;
}
};
567. 字符串的排列
这题其实只要前面题都做了，就一模一样的解法套就完事了。然后我看评论中很多用vector代替map来做字符记录的。这种做法是利用char对应ascii码0到128的特点，开一个128大小的vector来模拟map，比如当前有一个字母a（ascii好像是97吧），那就把vector[97]+1，到时候查询字母a的频数也直接来查vector[97]就好了。滑窗还是正常的滑，并且这题还是固定大小的窗口，所以比较简单。用map会慢一些，因为首先map查询O(logn)，比不上数组下标的O(1)。另外遍历到非s1中字符的时候，我的做法将当前记录的map清零，这个可能也比较费时。用vector模拟map的解法我偷懒没写，想看的就点进评论区看看吧。。。
class Solution {
public:
bool checkInclusion(string s1, string s2) {
if(s2.size()<s1.size()){
return false;
}
int s2_siz=s2.size(),s1_siz=s1.size();
int le=0,ri=0,cnt=0;
map<char,int> dic;
for(char c:s1){
dic[c]+=1;
}
map<char,int>cur_dic;
while(ri<s2_siz){
char c=s2[ri++];
if(dic.count(c)){ //匹配
++cnt;
cur_dic[c]++;
while(dic[c]<cur_dic[c]){
cur_dic[s2[le]]--;
++le;
--cnt;
}
if(cnt==s1_siz){
return true;
}
}
else{ //不匹配
cnt=0;
cur_dic.clear();
le=ri;
}
}
return false;
}
};
727. 最小窗口子序列
这题我一开始是这样思考的：要找S的最短子串满足T中字符按序存在于该子串内。那显然就不能像之前的题目那样用map了，因为此题多了出现顺序的要求。那么就先找第一个符合条件的子串再看看怎么继续下去。假如目前找到了0开始到i结束的子串包含T的子序列，那么从0开始的最短子串就是这个了。那下面把左边界右移一位再从1开始找？这样的复杂度不就是n^2了吗。然后我就卡在这了。
憋了半天还是去看评论区了，大致看到了两种解法：
第一种：评论链接和我的基本思路是一致的，但作者用了一种特别的优化。关键思路：如果当前我们找到了一个满足条件的子串，索引i到j，即i处对应T[0]，j处对应T[-1]。
那么在该子串中满足条件的最短子串就是从右到左倒序依次查找T[-1],T[-2],T[-2]…到T[0]的子串（因为这个子串肯定不比j-i+1长，所以是最短的没毛病）。咋证明呢，很简单：对于i到j的串，因为最后一个元素是T[-1]，而且这个元素只出现了这一次，那么最终的子串必须包含它。所以我们从末尾倒着往前查找T中的字符，最终找到的子串就一定是当前i到j串中满足条件的最短子串。比较遗憾的是，作者的代码格式不是很清晰，故我又自己写了一份在下面，思路完全参照作者。这个时间应该是最优O(n)，最差O(n^2)，比如S是100个字符a，T是aa，每次循环相当于只移动了一位。
class Solution {
public:
string minWindow(string S, string T) {
//找S的最短子串w，w中要包含T中的全部字符，并按顺序出现。
if(S.size()<T.size()){
return "";
}
int s_size=S.size(),t_size=T.size(),le=0,ri=0,cnt=0,_start=0,_end=INT32_MAX;
while(ri<s_size){
if(S[ri]==T[cnt]){//匹配
++cnt;
if(cnt==t_size){//找到符合条件的子串[le,ri]
le=ri;
while(cnt){//从ri倒序查找T[-1],T[-2]..到T[0]
if(S[le]==T[cnt-1]){
--cnt;
}
--le;
}
//此时cnt==0，S[le+1]==T[0]
++le;
if(ri-le+1<_end-_start){
_start=le;
_end=ri+1;
}
++le;
ri=le-1;
}
++ri;
}
else{
++ri;
}
}
return _end==INT32_MAX?"":S.substr(_start,_end-_start);
}
};
然后我又看到一种动态规划解法，tql，没想到。
思路是二维dp，dp[i][j]存储T截止到j的字符串t1，S截止到i包含t1子序列的左边界索引，这个时间是稳定的O(n^2)。
class Solution {
public:
string minWindow(string S, string T) {
if(S.size()<T.size()){
return "";
}
int s_size=S.size(),t_size=T.size();
vector<vector<int>>dp(t_size,vector<int>(s_size,-1));
int le=0,ri=INT32_MAX;
//dp[i][j]存储S截止j的字符串s1，T截止i的字符串t1，s1包含t1的子序列的左索引
if(S[0]==T[0]){
dp[0][0]=0;
}
for(int i=1;i<s_size;++i){
if(S[i]==T[0]){
dp[0][i]=i;
}
else if(dp[0][i-1]!=-1){
dp[0][i]=dp[0][i-1];
}
}
for(int i=1;i<t_size;++i){
for(int j=i;j<s_size;++j){
if(S[j]==T[i]){
dp[i][j]=dp[i-1][j-1];
}
else{
dp[i][j]=dp[i][j-1];
}
}
}
// for(auto row:dp){
// for(auto col:row){
// cout<<col<<" ";
// }cout<<endl;
// }
for(int i=t_size;i<s_size;++i){
if(dp[t_size-1][i]!=-1 and i-dp[t_size-1][i]<ri-le){
le=dp[t_size-1][i];
ri=i;
}
}
return ri==INT32_MAX?"":S.substr(le,ri-le+1);
}
};
完结撒花！2019年11月17日 00:46:57
1368
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
