Проблема в оптимизации алгоритма (Нахождение подстрок в строке, работа с большими данными)

if(s[i]==s[j] && s[i-1]==s[j-1] && s[i-2]==s[j-2] && s[i-3]==s[j-3] && s[i-4]==s[j-4])
{
    start_otl=i-j;
    jt = i-start_otl;
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <climits>
#include <string_view>
#include <unordered_map>
#include <functional>
 
 
int main()
{
    std::string str{ "abaaabababa" };
    int n = str.size(), k = 3, a = 12, b = 13;
    std::unordered_map<size_t, std::pair<char, std::vector<int>>> umpPrep; // готовые подстроки длиной k(не сами подстроки а их хеш) и самый частый символ
 
    // в цикле делим строку str на подстроки. Каждую подстроку длиной k кидаем в ump вместе с самым частым символом
    for (int i = 0; i + k < str.size(); ++i)
    {
        auto h = std::hash<std::string_view>{}({ &str[i], (size_t)k });
        auto pr = umpPrep.emplace(h, std::pair<char, std::vector<int>>{ CHAR_MAX, std::vector<int>(26) }); // хеш подстроки
        auto it = pr.first;
        auto& v = it->second.second;
        auto& cmax = it->second.first;
        char c = str[i + k]; // символ
        ++v[c - 'a'];
        if (pr.second || (v[c - 'a'] > v[cmax] || (v[c - 'a'] == v[cmax] && c - 'a' < cmax)))
        {
            cmax = c - 'a'; // обновляем инфу о самом частом символе
        }
    }
 
    std::unordered_map<size_t, char> ump; // готовые подстроки длиной k(не сами подстроки а их хеш) и самый частый символ
    for (auto const& [k, v] : umpPrep)
    {
        ump.emplace(k, v.first + 'a');
    }
    umpPrep.clear();
 
    // в цикле добавляем в конец строки str  b-n букв
    for (int i = 0; i < b - n; ++i)
    {
        auto h = std::hash<std::string_view>{}({ str.end() - k, str.end()});
        auto pr = ump.emplace(h, 'a');
        auto it = pr.first;
        char c = it->second;
        str += c;
    }
    std::cout << std::string_view{str.end() - (b-a+1), str.end()} << "\n";
    int yy = 0;
}

#include <iostream>
#include <string>
#include <cmath>
#include <unordered_map>
#include <vector>
#include <map>
#include <chrono>
#include <iomanip>
#include <string_view>
using namespace std;
const long long P = 99999773;
const long long m = 10000000019;
long long H(string_view s)
{
    long long hashh = 0;
    for(int i=0;i<s.size();i++)
    {
        hashh=(hashh*P+s[i])%m;
    }
    return hashh;
}
long long RH(long long prevHash, char prevPat, char newPat, long long multiplier)
{
    long long hashCode = prevHash;
    hashCode+=m;
    hashCode-=(multiplier*prevPat)%m;
    hashCode*=P;
    hashCode+=newPat;
    hashCode%=m;
    return hashCode;
}
int main()
{
    long long n,k,a,b;
    string s;
    cin>>n>>k>>a>>b>>s;
    auto start_time = chrono::high_resolution_clock::now();
    long long multiplier = 1;
    string_view pt{s};
    for(int i=1;i<k;i++)
    {
        multiplier=multiplier * P;
        multiplier=multiplier % m;
    }
    long long ph = H(pt.substr(n-k,k));
    unordered_map<long long, unordered_map<char,int>> patterns;
    unordered_map<long long,char>pats;
    long long start_hash=H(pt.substr(0,k));
 
    int iter=0;
    for(int i=0;i+k<n;i++)
    {
        patterns[start_hash][pt[i+k]]++;
        start_hash=RH(start_hash,pt[i],pt[i+k],multiplier);
        iter=i;
    }
    for(auto s:patterns)
    {
        int flag=0;
        char flg;
        for(auto d:s.second)
        {
            if(patterns[s.first][d.first]>flag)
            {
                flag=patterns[s.first][d.first];
                flg=d.first;
            }
            if(patterns[s.first][d.first]==flag)
                flg=min(flg,d.first);
        }
        pats[s.first]=flg;
    }
 
    int flag=0;
    char flg;
    for(int i=1;i<=20000;i++)
    {
        if(pats.count(ph)==0)
        {
            s.push_back('a');
            pt=string_view{s};
            start_hash=ph;
            ph=RH(ph,pt[s.size()-k-1],pt[s.size()-1], multiplier);
            patterns[start_hash][pt[s.size()-1]]++;
            for(auto df:patterns[start_hash])
            {
                if(patterns[start_hash][df.first]>flag)
                {
                    flag=patterns[start_hash][df.first];
                    flg=df.first;
                }
                if(patterns[start_hash][df.first]==flag)
                    flg=min(flg,df.first);
            }
            pats[start_hash]=flg;
            flg=NULL;
            flag=0;
            continue;
        }
        s.push_back(pats[ph]);
        pt=string_view{s};
        start_hash=ph;
        ph=RH(ph,pt[s.size()-k-1],pt[s.size()-1],multiplier);
 
        patterns[start_hash][pt[s.size()-1]]++;
        for(auto df:patterns[start_hash])
        {
            if(patterns[start_hash][df.first]>flag)
            {
                flag=patterns[start_hash][df.first];
                flg=df.first;
            }
            if(patterns[start_hash][df.first]==flag)
                flg=min(flg,df.first);
        }
        pats[start_hash]=flg;
        flg=NULL;
        flag=0;
    }
 
    auto end_time = chrono::high_resolution_clock::now();
    auto duration = chrono::duration_cast<chrono::duration<double>>(end_time - start_time);
 
    cout<<pt.substr(n+19000,1000)<<"\n";
    cout<<"Patterns: "<<sizeof(patterns)/1024.0<<" KB\n";
    cout<<"Pats size: "<<pats.size()<<"\n";
    cout<<"Patterns size: "<<patterns.size()<<"\n";
    cout << fixed << setprecision(2) << "Program execution time: " << duration.count() << " seconds" << endl;
    return 0;
}