1297. Maximum Number of Occurrences of a Substring

超时，测试了一下，上述存储操作就容易超时，需要优化。（通过37个测试）

class Solution {
public:
    // 子串不能断开，必须连续
    
    bool judge(int maxLetters, string s){
        vector<int> res(26, 0);
        for (int i=0;i<s.size();i++){
            res[int(s[i]-'a')]++;
        }
        
        int count = 0;
        for (int i=0;i<26;i++){
            if (res[i]!=0){
                count++;
            }
        }
        
        if (maxLetters>=count){
            return true;
        }
        else{
            return false;
        }
    }
    
    int maxFreq(string s, int maxLetters, int minSize, int maxSize) {
        map<string, int> res;
        for (int len=minSize;len<=maxSize;len++){
            for(int start=0;start<=s.size()-len;start++){
                // [start, start+len-1]
                string temp = s.substr(start, len);
                if (res.find(temp)!=res.end()){
                    res[temp] ++;                    
                }
                else{
                    res[temp] = 1;
                }
            }
        }
        
        int max = 0;
        for (map<string, int>::iterator it=res.begin();it!=res.end();it++){
            //cout<<it->first<<" "<<it->second<<endl;
            if (judge(maxLetters, it->first)){
                max = max > it->second?max:it->second;
            }
        }
        return max;

    }
};

第二次修改，我采用了优化策略，对于保存字符长度已经超越目标值的部分，直接删除。但还是超时。（通过39个测试）

class Solution {
public:
    // 子串不能断开，必须连续
    
    bool judge(int maxLetters, string s){
        vector<int> res(26, 0);
        for (int i=0;i<s.size();i++){
            res[int(s[i]-'a')]++;
        }
        
        int count = 0;
        for (int i=0;i<26;i++){
            if (res[i]!=0){
                count++;
            }
        }
        
        if (maxLetters>=count){
            return true;
        }
        else{
            return false;
        }
    }
    
    int maxFreq(string s, int maxLetters, int minSize, int maxSize) {
        map<string, int> res;
        for(int start=0;start<s.size();start++){
            for(int len=minSize;len<=maxSize;len++){
                if(len+start>s.size()){
                    break;
                }
                // [start, start+len-1]
                string temp = s.substr(start, len);
                if (!judge(maxLetters, temp)){
                    break;
                }
                if (res.find(temp)!=res.end()){
                    res[temp] ++;                    
                }
                else{
                    res[temp] = 1;
                }   
            }
        }
        
        
        int max = 0;
        for (map<string, int>::iterator it=res.begin();it!=res.end();it++){
            //cout<<it->first<<" "<<it->second<<endl;
            if (judge(maxLetters, it->first)){
                max = max > it->second?max:it->second;
            }
        }
        return max;

    }
};

继续优化 (勉强通过40个测试)

class Solution {
public:
    // 子串不能断开，必须连续
    
    int maxFreq(string s, int maxLetters, int minSize, int maxSize) {
        vector<string> res;
        for(int start=0;start<s.size();start++){
           
            if(minSize+start>s.size()){
                break;
            }
            
            // save minSize-1
            int count = 0;
            map<char, int> cnt;
            for (int i=start;i<start+minSize-1;i++){
                if (cnt.find(s[i])==cnt.end()){
                    cnt[s[i]] = 1;
                    count ++;
                    if (count>maxLetters){continue;}
                }
            }
            if (count>maxLetters){continue;}

            
            for(int len=minSize;len<=maxSize;len++){
                if(len+start>s.size()){
                    break;
                }
                
                if (cnt.find(s[start+len-1])==cnt.end()){
                    cnt[s[start+len-1]] = 1;
                    count ++;
                    if (count>maxLetters){break;}
                }
                
                // [start, start+len-1]
                string temp = s.substr(start, len);
                res.push_back(temp);
            }
        }
        
      // find max_count in res;
        std::unordered_map<string, int> temp;
        for(int i=0;i<res.size();i++){
            if (temp.count(res[i])==0){
                temp.insert({res[i], 1});
            }
            else{
                temp[res[i]] += 1;
            }
        }
        
        int max = 0;
        for(auto it=temp.begin();it!=temp.end();it++){
            max = max > it->second?max:it->second;
        }
        return max;

    }
};

查看答案，加上贪心假设—最优结果必定出现在size=minSize的时候，空间和时间得到进一步优化。

class Solution {
public:
    // 子串不能断开，必须连续
    
    int maxFreq(string s, int maxLetters, int minSize, int maxSize) {
        vector<string> res;
        for(int start=0;start<s.size();start++){
           
            if(minSize+start>s.size()){
                break;
            }
            
            // save minSize-1
            int count = 0;
            map<char, int> cnt;
            for (int i=start;i<start+minSize-1;i++){
                if (cnt.find(s[i])==cnt.end()){
                    cnt[s[i]] = 1;
                    count ++;
                    if (count>maxLetters){continue;}
                }
            }
            if (count>maxLetters){continue;}

            
            for(int len=minSize;len<=minSize;len++){
                if(len+start>s.size()){
                    break;
                }
                
                if (cnt.find(s[start+len-1])==cnt.end()){
                    cnt[s[start+len-1]] = 1;
                    count ++;
                    if (count>maxLetters){break;}
                }
                
                // [start, start+len-1]
                string temp = s.substr(start, len);
                res.push_back(temp);
            }
        }
        
      // find max_count in res;
        std::unordered_map<string, int> temp;
        for(int i=0;i<res.size();i++){
            if (temp.count(res[i])==0){
                temp.insert({res[i], 1});
            }
            else{
                temp[res[i]] += 1;
            }
        }
        
        int max = 0;
        for(auto it=temp.begin();it!=temp.end();it++){
            max = max > it->second?max:it->second;
        }
        return max;

    }
};