Language: C++

#include<bits/stdc++.h>
using namespace std;using ll=long long;using vi=vector<int>;using vvi=vector<vi>;using vl=vector<ll>;using vvl=vector<vl>;using P=pair<int,int>;using PL=pair<ll,ll>;using vp=vector<P>;using vpl=vector<PL>;
template<typename T>constexpr auto inf=numeric_limits<T>::max()/2;constexpr int INF=inf<int>,MOD=1000000007;constexpr ll LINF=inf<ll>;
#define _ol3(_1,_2,_3,name,...)name
#define _rep(i,n)_repi(i,0,n)
#define _repi(i,a,b)for(int i=a,i##_l=(b);i<i##_l;++i)
#define REP(...)_ol3(__VA_ARGS__,_repi,_rep,)(__VA_ARGS__)
#define REPR(i,n)for(int i=n-1;i>=0;--i)
#define REPA(i,v)REP(i,v.size())
#define all(v)(v).begin(),(v).end()
#define bit(n)(1ll<<(n))
#define uniq(v)sort(all(v));v.erase(unique(all(v)),v.end())
#define F first
#define S second
#define endl '\n'
#define cho(n,a,b)cout<<((n)?a:b)<<endl
void YES(int n){cho(n,"YES","NO");}void Yes(int n){cho(n,"Yes","No");}void Poss(int n){cho(n,"Possible","Impossible");}
void _print(ostream&s){}template<class T,class...U>void _print(ostream&s,T&&t,U&&...u){s<<t<<(sizeof...(u)?' ':'\n');_print(s,u...);}
template<class...T>void print(T&&...t){_print(cout,t...);}
#ifndef LOCAL
struct osd{template<class T>osd&operator<<(const T&t){return*this;}};osd cer_;
#define dprint(...)
#define cerr cer_
#else
template<class...T>void dprint(T&&...t){_print(cerr,t...);}
#endif
template<class T>void chmax(T&a,const T&b){if(a<b)a=b;}template<class T>void chmin(T&a,const T&b){if(a>b)a=b;}
template<class T>ostream&operator<<(ostream&o,const vector<T>&v){for(auto&&i:v)o<<i<<' ';return o;}
template<class T>istream&operator>>(istream&i,vector<T>&v){for(T&j:v)i>>j;return i;}
template<class T,class U>ostream&operator<<(ostream&o,const pair<T,U>&p){return o<<p.F<<' '<<p.S;}
template<class T,class U>istream&operator>>(istream&i,pair<T,U>&p){return i>>p.F>>p.S;}
template<class T>ostream&operator<<(ostream&o,const set<T>&v){for(auto&&i:v)o<<i<<' ';return o;}
template<class T>ostream&operator<<(ostream&o,const multiset<T>&v){for(auto&&i:v)o<<i<<' ';return o;}
template<class T>vector<T>&operator<<(vector<T>&v,const T&t){v.push_back(t);return v;}
template<class T>set<T>&operator<<(set<T>&v,const T&t){v.insert(t);return v;}
template<class T>multiset<T>&operator<<(multiset<T>&v,const T&t){v.insert(t);return v;}

class string_view{
    string::const_iterator _begin,_end;
public:
    string_view(string::const_iterator start, string::const_iterator end):_begin(start),_end(end){}
    string_view(const string& s):_begin(s.begin()),_end(s.end()){}
    string_view(const string& s, size_t start, size_t len):_begin(s.begin()+start),_end(s.begin()+start+len){}
    string_view(string_view s, size_t start, size_t len):_begin(s.begin()+start),_end(s.begin()+start+len){}
    size_t size()const{return _end-_begin;}
    string::const_iterator begin()const{return _begin;}
    string::const_iterator end()const{return _end;}
    string_view substr(size_t pos, size_t n){return string_view(_begin+pos,_begin+pos+n);}
    const char&operator[](const size_t i)const{
        return _begin[i];
    }
    bool operator==(const string_view& s)const{
        if(this->size()!=s.size())return 0;
        REP(i,this->size())if(*(_begin+i)!=*(s.begin()+i))return 0;
        return 1;
    }
};
ostream& operator<<(ostream&o,string_view s){return o.write(&*(s.begin()), s.size());}

template<>
class std::hash<pair<string_view,string_view>>{
public:
    size_t operator ()(const pair<string_view,string_view>&p)const{ // 64bit unsigned
        return
        (size_t)(p.F.size()<1?0:p.F[0])<<(8*7) |
        (size_t)(p.F.size()<2?0:p.F[1])<<(8*6) |
        (size_t)(p.F.size()<3?0:p.F[2])<<(8*5) |
        (size_t)(p.F.size()<4?0:p.F[3])<<(8*4) |
        /*(size_t)(p.F.size()<5?0:p.F[4])<<(8*3) |
        (size_t)(p.F.size()<6?0:p.F[5])<<(8*2) |*/
        (size_t)(p.S.size()<1?0:p.S[0])<<(8*1) |
        (size_t)(p.S.size()<2?0:p.S[1])<<(8*0);
    }
};



unordered_map<pair<string_view, string_view>, int>
    func_cache;

int func(string_view s, string_view last){
    if(func_cache.find({s,last})!=func_cache.end())return func_cache[{s,last}];
    dprint("last:",last);
    dprint("buf:",s);
    int ma=0;
    if(s.size()==0)return 0;
    if( !(last.size()==1 && last[0]==s[0])&&
        (s.size()<2 || s[0]!=s[1]) &&
        (s.size()<3 || s[1]!=s[2])){
        int ret=func(string_view(s.begin()+1, s.end()), s.substr(0,1))+1;
        func_cache[{s,last}]=ret;
        return ret;
    }
    REP(i, min((int)s.size(),2)){
        if(!(last==s.substr(0,i+1)))chmax(ma,func(string_view(s.begin()+i+1, s.end()), s.substr(0,i+1))+1);
    }
    func_cache[{s,last}]=ma;
    return ma;
}
int main(){
    cin.tie(0);ios::sync_with_stdio(0);
    string s;
    cin>>s;
    /*for(int i=s.size()-1; i>=2; --i){//make cache
        func(string_view(s.begin()+i+1, s.end()), string_view(s.begin()+i-2, s.begin()+i));
        func(string_view(s.begin()+i+1, s.end()), string_view(s.begin()+i-1, s.begin()+i));
    }*/
    cout<<func(string_view(s), string_view(s.begin(), s.begin()))<<endl;
    return 0;
}


Compiler output:
a.cc:58:31: error: reference to 'string_view' is ambiguous
   58 | ostream& operator<<(ostream&o,string_view s){return o.write(&*(s.begin()), s.size());}
      |                               ^~~~~~~~~~~
In file included from /usr/include/c++/14/bits/basic_string.h:47,
                 from /usr/include/c++/14/string:54,
                 from /usr/include/c++/14/bitset:52,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:52,
                 from a.cc:1:
/usr/include/c++/14/string_view:770:9: note: candidates are: 'using std::string_view = class std::basic_string_view<char>'
  770 |   using string_view = basic_string_view<char>;
      |         ^~~~~~~~~~~
a.cc:38:7: note:                 'class string_view'
   38 | class string_view{
      |       ^~~~~~~~~~~
a.cc:58:31: error: 'string_view' has not been declared
   58 | ostream& operator<<(ostream&o,string_view s){return o.write(&*(s.begin()), s.size());}
      |                               ^~~~~~~~~~~
a.cc: In function 'std::ostream& operator<<(std::ostream&, int)':
a.cc:58:66: error: request for member 'begin' in 's', which is of non-class type 'int'
   58 | ostream& operator<<(ostream&o,string_view s){return o.write(&*(s.begin()), s.size());}
      |                                                                  ^~~~~
a.cc:58:78: error: request for member 'size' in 's', which is of non-class type 'int'
   58 | ostream& operator<<(ostream&o,string_view s){return o.write(&*(s.begin()), s.size());}
      |                                                                              ^~~~
a.cc: At global scope:
a.cc:61:34: error: template argument 1 is invalid
   61 | class std::hash<pair<string_view,string_view>>{
      |                                  ^~~~~~~~~~~
a.cc:61:34: error: template argument 2 is invalid
a.cc:61:45: error: template argument 1 is invalid
   61 | class std::hash<pair<string_view,string_view>>{
      |                                             ^~
a.cc:61:47: error: explicit specialization of non-template '<unnamed class>'
   61 | class std::hash<pair<string_view,string_view>>{
      |                                               ^
a.cc:63:58: error: template argument 1 is invalid
   63 |     size_t operator ()(const pair<string_view,string_view>&p)const{ // 64bit unsigned
      |                                                          ^
a.cc:63:58: error: template argument 2 is invalid
a.cc:63:58: error: template argument 1 is invalid
a.cc:63:58: error: template argument 2 is invalid
a.cc:63:58: error: template argument 1 is invalid
a.cc:63:58: error: template argument 2 is invalid
a.cc:63:30: error: invalid template-id
   63 |     size_t operator ()(const pair<string_view,string_view>&p)const{ // 64bit unsigned
      |                              ^~~~
a.cc:63:35: error: reference to 'string_view' is ambiguous
   63 |     size_t operator ()(const pair<string_view,string_view>&p)const{ // 64bit unsigned
      |                                   ^~~~~~~~~~~
/usr/include/c++/14/string_view:770:9: note: candidates are: 'using std::string_view = class std::basic_string_view<char>'
  770 |   using string_view = basic_string_view<char>;
      |         ^~~~~~~~~~~
a.cc:38:7: note:                 'class string_view'
   38 | class string_view{
      |       ^~~~~~~~~~~
a.cc:63:47: error: reference to 'string_view' is ambiguous
   63 |     size_t operator ()(const pair<string_view,string_view>&p)const{ // 64bit unsigned
      |                                               ^~~~~~~~~~~
/usr/include/c++/14/string_view:770:9: note: candidates are: 'using std::string_view = class std::basic_string_view<char>'
  770 |   using string_view = basic_string_view<char>;
      |         ^~~~~~~~~~~
a.cc:38:7: note:                 'class string_view'
   38 | class string_view{
      |       ^~~~~~~~~~~
a.cc:63:24: error: missing template argument list after 'std::pair'; template placeholder not permitted in parameter
   63 |     size_t operator ()(const pair<string_view,string_view>&p)const{ // 64bit unsigned
      |                        ^~~~~
      |                             <>
In file included from /usr/include/c++/14/bits/stl_algobase.h:64,
                 from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51:
/usr/include/c++/14/bits/stl_pair.h:89:12: note: 'template<class _T1, class _T2> struct std::pair' declared here
   89 |     struct pair;
      |            ^~~~
a.cc: In member function 'size_t<unnamed class>::operator()(...) const':
a.cc:65:18: error: 'p' was not declared in this scope
   65 |         (size_t)(p.F.size()<1?0:p.F[0])<<(8*7) |
      |                  ^
a.cc: At global scope:
a.cc:63:12: error: 'size_t<unnamed class>::operator()(...) const' invalid; an anonymous struct may only have public non-static data members [-fpermissive]
   63 |     size_t operator ()(const pair<string_view,string_view>&p)const{ // 64bit unsigned
      |            ^~~~~~~~
a.cc:74:2: error: abstract declarator '<unnamed class>' used as declaration
   74 | };
      |  ^
a.cc:78:44: error: template argument 1 is invalid
   78 | unordered_map<pair<string_view, string_view>, int>
      |                                            ^
a.cc:78:44: error: template argument 2 is invalid
a.cc:78:50: error: template argument 1 is invalid
   78 | unordered_map<pair<string_view, string_view>, int>
      |                                                  ^
a.cc:78:50: error: template argument 3 is invalid
a.cc:78:50: error: template argument 4 is invalid
a.cc:78:50: error: template argument 5 is invalid
a.cc:81:10: error: reference to 'string_view' is ambiguous
   81 | int func(string_view s, string_view last){
      |          ^~~~~~~~~~~
/usr/include/c++/14/string_view:770:9: note: candidates are: 'using std::string_view = class std::basic_string_view<char>'
  770 |   using string_view = basic_string_view<char>;
      |         ^~~~~~~~~~~
a.cc:38:7: note:                 'class string_view'
   38 | class string_view{
      |       ^~~~~~~~~~~
a.cc:81:25: error: reference to 'string_view' is ambiguous
   81 | int func(string_view s, string_view last){
      |                         ^~~~~~~~~~~
/usr/include/c++/14/string_view:770:9: note: candidates are: 'using std::string_view = class std::basic_string_view<char>'
  770 |   using string_view = basic_string_view<char>;
      |         ^~~~~~~~~~~
a.cc:38:7: note:                 'class string_view'
   38 | class string_view{
      |       ^~~~~~~~~~~
a.cc:81:41: error: expression list treated as compound expression in initializer [-fpermissive]
   81 | int func(string_view s, string_view last){
      |                                         ^
a.cc: In function 'int main()':
a.cc:108:16: error: reference to 'string_view' is ambiguous
  108 |     cout<<func(string_view(s), string_view(s.begin(), s.begin()))<<endl;
      |                ^~~~~~~~~~~
/usr/include/c++/14/string_view:770:9: note: candidates are: 'using std::string_view = class std::basic_string_view<char>'
  770 |   using string_view = basic_string_view<char>;
      |         ^~~~~~~~~~~
a.cc:38:7: note:                 'class string_view'
   38 | class string_view{
      |       ^~~~~~~~~~~
a.cc:108:32: error: reference to 'string_view' is ambiguous
  108 |     cout<<func(string_view(s), string_view(s.begin(), s.begin()))<<endl;
      |                                ^~~~~~~~~~~
/usr/include/c++/14/string_view:770:9: note: candidates are: 'using std::string_view = class std::basic_string_view<char>'
  770 |   using string_view = basic_string_view<char>;
      |         ^~~~~~~~~~~
a.cc:38:7: note:                 'class string_view'
   38 | class string_view{
      |       ^~~~~~~~~~~
a.cc:108:65: error: 'func' cannot be used as a function
  108 |     cout<<func(string_view(s), string_view(s.begin(), s.begin()))<<endl;
      |                                                                 ^