結果

問題 No.3239 Omnibus
コンテスト
ユーザー hint908
提出日時 2025-08-15 22:42:51
言語 C++23
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 1,282 ms / 10,000 ms
コード長 7,073 bytes
コンパイル時間 3,261 ms
コンパイル使用メモリ 293,360 KB
実行使用メモリ 239,916 KB
最終ジャッジ日時 2025-08-15 22:43:25
合計ジャッジ時間 32,060 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 1
other AC * 33
権限があれば一括ダウンロードができます

ソースコード

diff #
raw source code 

// #pragma GCC target("avx2")
// #pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")


#include<bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
template<class T> using VVV = V<VV<T>>;
template<class T> using VVVV = VV<VV<T>>;
#define rep(i,n) for(ll i=0ll;(i)<(n);(i)++)
#define REP(i,a,n) for(ll i=(a);(i)<(n);(i)++)
#define rrep(i,n) for(ll i=(n)-1;(i)>=(0ll);(i)--)
#define RREP(i,a,n) for(ll i=(n)-1;(i)>=(a);(i)--)
const long long INF = (1LL << 60);
const long long mod99 = 998244353;
const long long mod107 = 1000000007;
const long long mod = mod99;
#define eb emplace_back
#define be(v) (v).begin(),(v).end()
#define all(v) (v).begin(),(v).end()
#define foa(i,v) for(auto& (i) : (v))
#define UQ(v) sort(be(v)), (v).erase(unique(be(v)), (v).end())
#define UQ2(v,cmp) sort(be(v)), (v).erase(unique(be(v),cmp), (v).end())
#define UQ3(v,cmp) sort(be(v),cmp), (v).erase(unique(be(v)), (v).end())
#define UQ4(v,cmp,cmp2) sort(be(v), cmp), (v).erase(unique(be(v),cmp2), (v).end())
#define LB(x,v) (lower_bound(be(v),(x))-(v).begin())
#define LB2(x,v,cmp) (lower_bound(be(v),(x),(cmp))-(v).begin())
#define UB(x,v) (upper_bound(be(v),(x))-(v).begin())
#define UB2(x,v,cmp) (upper_bound(be(v),(x),(cmp))-(v).begin())
#define dout()  cout << fixed << setprecision(20)
#define randinit() srand((unsigned)time(NULL))

template<class T, class U> bool chmin(T& t, const U& u) { if (t > u){ t = u; return 1;} return 0; }
template<class T, class U> bool chmax(T& t, const U& u) { if (t < u){ t = u; return 1;} return 0; }


ll Rnd(ll L=0, ll R=mod99){return rand()%(R-L)+L;}


template <typename T, T (*OP)(T, T), T (*E)()>
struct dynamic_segtree { 
    vector<T> seg;
    vector<int> left, right;
    long long seg_size, _n;//葉の数
    
    dynamic_segtree( long long N) : seg(2, E()), left(2, 0), right(2, 0), seg_size(), _n(N){
        seg_size = 1;
        while(seg_size < N) seg_size <<= 1;
    }
    
    void set( long long idx, T x){ set(1, idx, 0, seg_size, x); }
    long long set(int node, long long idx,  long long l,  long long r, T x){
        if(node == 0){
            node = seg.size();
            seg.push_back(E());
            left.push_back(0);
            right.push_back(0);
        }
        if(l+1 == r){
            assert(l == idx);
            seg[node] = x;
            return node;
        }
        long long mid = (l+r)/2;
        if(idx < mid) left[node] = set(left[node], idx, l, mid, x);
        else right[node] = set(right[node], idx, mid, r, x);
        seg[node] = OP(seg[left[node]], seg[right[node]]);
        return node;
    }

    void apply(long long idx, T x){ apply(1, idx, 0, seg_size, x); }
    long long apply(int node,  long long idx,  long long l,  long long r, T x){
        if(node == 0){
            node = seg.size();
            seg.push_back(E());
            left.push_back(0);
            right.push_back(0);
        }
        if(l+1 == r){
            seg[node] = OP(x, seg[node]);
            return node;
        }
        long long mid = (l+r)/2;
        if(idx < mid) left[node] = apply(left[node], idx, l, mid, x);
        else right[node] = apply(right[node], idx, mid, r, x);
        seg[node] = OP(seg[left[node]], seg[right[node]]);
        return node;
    }
    T get( long long idx){
         long long l = 0, r = seg_size;
        int node = 1;
        while(node and l+1!=r){
             long long mid = (l+r)>>1;
            if(idx < mid) node = left[node];
            else node = right[node];
        }
        return seg[node];
    }    
    
    T prod( long long a,  long long b) { return prod(a, b, 1, 0, seg_size); }
    T prod( long long a, long long b, int idx, long long l, long long r){
        if(a >= r or b <= l or idx == 0) return E();
        if(a <= l and b >= r) return seg[idx];
        
        T v1 = prod(a, b, left[idx], l, (l + r) >> 1);
        T v2 = prod(a, b, right[idx], (l + r) >> 1, r);
        return OP(v1, v2);
    }
    T all_prod(){ return seg[1]; }

    // template<class F>
    // int max_right(int left, F f) {
    //     if(left >= _n) return _n;
    //     if(left < 0) left = 0;
    //     T s = E();
    //     left += seg_size;
    //     do{
    //         while(left % 2 == 0) left >>= 1;
    //         if(!f(OP(s, seg[left]))){
    //             while(left < seg_size){
    //                 left <<= 1;
    //                 if(f(OP(s, seg[left]))){
    //                     s = OP(s, seg[left]);
    //                     left++;
    //                 }
    //             }
    //             return left - seg_size;
    //         }
    //         s = OP(s, seg[left]);
    //         left++;
    //     }while((left & (left-1)));
    //     return _n;
    // };

    // template<class F>
    // int min_left(int right, F f) {
    //     if(right <= 0) return 0;
    //     if(right >= _n) right = _n;
    //     T s = E();
    //     right += seg_size;
    //     do{
    //         while(right % 2 == 0) right >>= 1;
    //         if(right != 1) right --;
    //         if(!f(OP(seg[right], s))){
    //             while(right < seg_size){
    //                 right <<= 1;
    //                 right |= 1;
    //                 if(f(OP(seg[right], s))){
    //                     s = OP(seg[right], s);
    //                     right ^= 1;
    //                 }
    //             }
    //             return right - seg_size;
    //         }
    //         s = OP(seg[right], s);
    //     }while((right & (right-1)));
    //     return 0;
    // };
};


pair<ll,ll> e(){return {0,0};}
pair<ll,ll> op(pair<ll,ll> L, pair<ll,ll> R){
    L.first += R.first;
    L.second += R.second;
    return L;
}



void solve(){
    ll n,q;
    string s;
    cin >> n >> q >> s;
    ll X = 26 * 26 * 26;
    V<dynamic_segtree<pair<ll,ll>, op, e>> seg;
    rep(i, X) seg.push_back(dynamic_segtree<pair<ll,ll>, op, e>(200100));
    
    auto f = [&](string t) -> ll {
        // cout << t << endl;
        return (t[0] - 'a') * 676 + (t[1] - 'a') * 26 + t[2] - 'a';
    };
    rep(i, n-2){
        seg[f(s.substr(i, 3))].set(i, {i, 1});
    }
    
    while(q--){
        ll t;
        cin >> t;
        if(t == 1){
            ll p;
            char x;
            cin >> p >> x;
            p--;
            REP(i, max(0ll, p-2), min(n-2, p+1)){
                seg[f(s.substr(i, 3))].set(i, {0, 0});
            }
            s[p] = x;
            REP(i, max(0ll, p-2), min(n-2, p+1)){
                seg[f(s.substr(i, 3))].set(i, {i, 1});
            }
        }else{
            ll l,r;
            string t;
            cin >> l >> r >> t;
            l--;
            ll id = f(t);
            r -= 2;
            auto[a,b] = seg[id].prod(l, max(r, l));
            cout << a - l*b + b << '\n';
        }
    }
    
}





int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int t=1;
    // cin >> t;
    rep(i,t) solve();
}
0