結果

問題 No.3244 Range Multiple of 8 Query
コンテスト
ユーザー hint908
提出日時 2025-08-22 21:53:38
言語 C++23
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 3,360 ms / 5,000 ms
コード長 6,788 bytes
コンパイル時間 3,257 ms
コンパイル使用メモリ 294,108 KB
実行使用メモリ 93,752 KB
最終ジャッジ日時 2025-08-22 21:54:49
合計ジャッジ時間 64,798 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge2
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 1
other AC * 40
権限があれば一括ダウンロードができます

ソースコード

diff # 

// #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 segtree { 
    vector<T> seg;
    int seg_size, _n;//葉の数
    
    segtree(int N) : seg(), seg_size(), _n(N) {
        seg_size = 1;
        while(seg_size < N) seg_size <<= 1;
        seg.resize(seg_size<<1, E());
    }
    segtree(const vector<T> a) : seg(), seg_size(), _n(a.size()) {
        int N = a.size();
        seg_size = 1;
        while(seg_size < N) seg_size <<= 1;
        seg.resize(seg_size<<1, E());
        for(int i=0; i<N; i++) seg[i + seg_size] = a[i];
        for(int i = seg_size-1; i > 0; i --){
            seg[i] = OP(seg[(i<<1)], seg[(i<<1)|1]);
        }
    }
    
    void set(int idx, T x){
        idx += seg_size;
        seg[idx] = x;
        update(idx);
    }
    T get(int idx){
        idx += seg_size;
        return seg[idx];
    }
    
    void apply(int idx, T x){
        idx += seg_size;
        seg[idx] = OP(seg[idx], x);
        update(idx);
    }

    void update(int idx){
        while(idx > 1){
            idx >>= 1;
            seg[idx] = OP(seg[idx<<1], seg[(idx<<1)|1]);
        }
    }
    
    
    T prod(int left, int right) {
        if(left < 0) left = 0;
        if(right > _n) right = _n;
        if(left > right) return E();

        left += seg_size;
        right += seg_size;

        T retl= E(), retr = E();
        {
            int L = left, R = right;
            while(L < R){
                if(L&1){
                    retl = OP(retl, seg[L]);
                    L++;
                }
                if(R&1){
                    R--;
                    retr = OP(seg[R], retr);
                }
                L >>= 1;
                R >>= 1;
            }
        }
        return OP(retl, retr);
    }
    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;
    };
};


ll e(){return -INF;}
ll op(ll L, ll R){return max(L, R);}




void solve(){
    ll n,q;
    string s;
    cin >> n >> q >> s;
    V<segtree<ll, op, e>> seg(10, segtree<ll, op, e>(n));
    rep(i, n){
        ll x = s[i] - '0';
        seg[x%8].set(i, i);
    }
    V<ll> can;
    VV<pair<ll,ll>> vv(1000, V<pair<ll,ll>>(3));
    for(ll i=0; i<1000; i+=8){
        ll a = i%10;
        ll b = i/10%10;
        ll c = i/100%10;
        if(a >= 8 or b >= 8 or c >= 8) continue;
        can.eb(i);
        vv[i][0] = {a, 0};
        vv[i][1] = {b, (a==b)};
        vv[i][2] = {c, (a==c) + (b==c)};
    }
    
    while(q--){
        ll l,r;
        cin >> l >> r;
        l--;
        
        VV<ll> v(8, V<ll>(3, -INF));
        rep(i, 8){
            ll m = r;
            rep(j, 3){
                v[i][j] = seg[i].prod(l, m);
                m = v[i][j];
                if(m < l){
                    v[i][j] = -INF;
                    break;
                }
            }
        }
        ll ans = INF;
        if(r-l >= 3){
            for(auto i:can){
                ll a = 0;
                V<ll> w;
                rep(j, 3){
                    auto[x,y] = vv[i][j];
                    w.eb(v[x][y]);
                }
                rep(j, 3) REP(k, j+1, 3) if(w[j] < w[k]) w[k] --;
                rep(j, 3) a += (r-j-1) - w[j];
                chmin(ans, a);
            }
        }else if(r-l==1){
            if((s[l] - '0')%8 == 0) ans = 0;
        }else if(r-l==2){
            ll a = s[l] - '0';
            ll b = s[l+1] - '0';
            if((b*10+a) % 8 == 0) ans = 1;
            if((a*10+b) % 8 == 0) ans = 0;
        }
        if(ans > INF/2) ans = -1;
        cout << ans << '\n';
    }
    
}

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