C++ 我怎样才能使这个C++；代码更高效

这是一个关于“无重复字符的最长子字符串”的leetcode问题 我在987失败了（这是最后一个测试用例） 我失败的原因是“超过了时间限制”

有人能给我一些建议来修复我的代码吗

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        vector<char> answer;
        vector<char> temp;
        int len = s.length();
        for ( int a = 0; a < len;a++ ){
            for( int aa = a; aa < len;aa++ ){
                temp.push_back(s[aa])    ;        
                if ( repeat(temp) ){
                    temp.pop_back();
                    changeAnswer(temp,answer);
                    temp.clear();
                    aa = len;
                }
                changeAnswer(temp,answer);
            }
        }


        return answer.size();
    }

    bool repeat(vector<char> temp){
        if ( temp.size() < 2 )
            return false;
        for ( int a = 0; a < temp.size();a++ )
            for ( int aa = a+1; aa < temp.size(); aa++ )
                if ( temp[aa] == temp[a] )
                    return true;
        return false;
    }

    void changeAnswer( vector<char> &temp, vector<char> &answer ){
        if ( temp.size()>answer.size() )
             answer = temp;

    }
}; 

类解决方案{
公众：
int lengthOfLongestSubstring（字符串s）{
向量答案；
向量温度；
int len=s.length（）；
对于（int a=0；aanswer.size（））
答案=温度；
}
}; 

看来您正在使用一种完全暴力的方法来解决这个问题。如果“n”是字符串的长度，则解决方案的时间复杂度为O（n^2）。如果字符串长度在10^5范围内，则时间限制肯定会超过。首先，您应该尝试优化代码，使其在O（n）时间内工作。 以下是您可以做的： 我认为散列在这种情况下会有所帮助。您可以将最后出现的字符存储在hashMap或无序_映射中，并检查当前字符是否已存在于映射中。如果是这样，则只需计算该字符最后一次出现后的字符数。要跟踪从何处开始计算字符，只需维护一个变量，该变量存储具有唯一字符的子字符串的第一个索引（如我在下面的代码中使用的“p”）。 以下是我对上述内容的实施：

int lengthOfLongestSubstring(string s) {
    unordered_map<char, int> mp;
    int n = (int)s.length();
    if(n == 0){
        return 0;
    }
    int res = 1;
    int p = 0;
    mp[s[0]] = 0;
    for(int i = 1; i < n ; i++){

        if(mp.find(s[i]) == mp.end()){
            res = max(res, i-p+1);
            mp[s[i]] = i;
        }
        else{
            char ch = s[i];
            int temp = mp[ch];
            if(p <= temp)
                p = temp + 1;
            res = max(res, i - p + 1);
            mp[ch] = i;
        }

    }
    return res;

}

int lengthOfLongestSubstring（字符串s）{
无序地图mp；
int n=（int）s.length（）；
如果（n==0）{
返回0；
}
int res=1；
int p=0；
mp[s[0]]=0；
对于（int i=1；i如果（p看起来您正在使用一种完全暴力的方法来解决这个问题。如果'n'是字符串的长度，那么您的解决方案的时间复杂度是O（n^2）。如果字符串长度在10^5范围内，时间限制肯定会超过。首先，您应该尝试优化代码，使其在O（n）时间内工作。
以下是您可以做的：
我认为散列在这种情况下会很有帮助。您可以在散列映射或无序映射中存储最后一次出现的字符，并检查当前字符是否已经存在于映射中。如果是这样，您只需要计算该字符最后一次出现后的字符。要跟踪从何处开始计算字符，您必须简单y维护一个变量，该变量存储具有唯一字符的子字符串的第一个索引（如我在下面的代码中使用的“p”）。
以下是我对上述内容的实施：

int lengthOfLongestSubstring(string s) {
    unordered_map<char, int> mp;
    int n = (int)s.length();
    if(n == 0){
        return 0;
    }
    int res = 1;
    int p = 0;
    mp[s[0]] = 0;
    for(int i = 1; i < n ; i++){

        if(mp.find(s[i]) == mp.end()){
            res = max(res, i-p+1);
            mp[s[i]] = i;
        }
        else{
            char ch = s[i];
            int temp = mp[ch];
            if(p <= temp)
                p = temp + 1;
            res = max(res, i - p + 1);
            mp[ch] = i;
        }

    }
    return res;

}

int lengthOfLongestSubstring（字符串s）{
无序地图mp；
int n=（int）s.length（）；
如果（n==0）{
返回0；
}
int res=1；
int p=0；
mp[s[0]]=0；
对于（int i=1；i如果（p）欢迎使用！如果你的代码基本上可以工作，你应该要求对其进行改进，但它是。这基本上是一个蛮力。至少有一个测试预计会失败。你需要使用滑动窗口方法来解决这样的问题。好的，我明白了。下次我会小心的@林子軒 您可以更改算法。这个问题不会被接受，只需稍作改进。@FatemehKarimi您是对的。现在我正试图找出以下答案。欢迎使用！如果您的代码基本上可以运行，您应该要求对其进行改进，但它是。这基本上是一种蛮力。而且至少有一个测试预计可以运行。您需要对这样的问题使用滑动窗口方法。好的，我明白了。下次我会小心的@林子軒 您可以更改算法。只要稍加改进，这个问题就不会被接受。@FatemehKarimi您是对的。现在我正试图找出下面的答案。