Submission #790130

#	Time	Username	Problem	Language	Result	Execution time	Memory
790130		GrindMachine	Street Lamps (APIO19_street_lamps)	C++17	20 / 100	266 ms	22072 KiB

street_lamps

// Om Namah Shivaya

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

template<typename T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL)
#define pb push_back
#define endl '\n'
#define sz(a) a.size()
#define setbits(x) __builtin_popcountll(x)
#define ff first
#define ss second
#define conts continue
#define ceil2(x, y) ((x + y - 1) / (y))
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define yes cout << "Yes" << endl
#define no cout << "No" << endl

#define rep(i, n) for(int i = 0; i < n; ++i)
#define rep1(i, n) for(int i = 1; i <= n; ++i)
#define rev(i, s, e) for(int i = s; i >= e; --i)
#define trav(i, a) for(auto &i : a)

template<typename T>
void amin(T &a, T b) {
    a = min(a, b);
}

template<typename T>
void amax(T &a, T b) {
    a = max(a, b);
}

#ifdef LOCAL
#include "debug.h"
#else
#define debug(x) 42
#endif

/*



*/

const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
const int inf1 = int(1e9) + 5;
const ll inf2 = ll(1e18) + 5;

template<typename T>
struct fenwick {
    int siz;
    vector<T> tree;

    fenwick(int n) {
        siz = n;
        tree = vector<T>(n + 1);
    }

    int lsb(int x) {
        return x & -x;
    }

    void build(vector<T> &a, int n) {
        for (int i = 1; i <= n; ++i) {
            int par = i + lsb(i);
            tree[i] += a[i];

            if (par <= siz) {
                tree[par] += tree[i];
            }
        }
    }

    void pupd(int i, T v) {
        while (i <= siz) {
            tree[i] += v;
            i += lsb(i);
        }
    }

    T sum(int i) {
        T res = 0;

        while (i) {
            res += tree[i];
            i -= lsb(i);
        }

        return res;
    }

    T query(int l, int r) {
        if (l > r) return 0;
        T res = sum(r) - sum(l - 1);
        return res;
    }
};

void solve(int test_case)
{
    int n,q; cin >> n >> q;
    vector<int> a(n+5);
    rep1(i,n){
        char ch; cin >> ch;
        a[i] = ch-'0';
    }

    set<array<int,3>> active;
    vector<array<int,3>> segs;

    {
        int l = -1;
        rep1(i,n){
            if(!a[i]){
                if(l != -1){
                    active.insert({l,i-1,0});
                }

                l = -1;
            }
            else{
                if(l == -1){
                    l = i;
                }
            }
        }

        if(l != -1){
            active.insert({l,n,0});
        }
    }

    auto get_seg = [&](int i){
        auto it = active.upper_bound({i+1,-1,-1});
        if(it == active.begin()) return active.end();
        else{
            it--;
            auto [l,r,t] = *it;
            if(l <= i and r >= i){
                return it;
            }
            else{
                return active.end();
            }
        }
    };

    vector<pii> upds;
    vector<array<int,3>> queries;

    rep1(id,q){
        string t; cin >> t;
        if(t == "toggle"){
            int i; cin >> i;
            upds.pb({i,id});
        }
        else{
            int l,r; cin >> l >> r;
            r--;
            queries.pb({l,r,id});
        }
    }

    for(auto [i,id] : upds){
        a[i] ^= 1;

        if(!a[i]){
            // unset
            auto it = get_seg(i);
            assert(it != active.end());
            auto [l,r,t] = *it;
            segs.pb({l,r,id-t});
            active.erase(it);

            if(l <= i-1){
                active.insert({l,i-1,id});
            }
            if(i+1 <= r){
                active.insert({i+1,r,id});
            }
        }
        else{
            // set
            auto it1 = get_seg(i-1);
            auto it2 = get_seg(i+1);
            
            int l = -1, r = -1;

            if(it1 != active.end()){
                auto curr = *it1;
                active.erase(it1);
                l = curr[0];                    
                segs.pb({curr[0],curr[1],id-curr[2]});
            }

            if(it2 != active.end()){
                auto curr = *it2;
                active.erase(it2);
                r = curr[1];
                segs.pb({curr[0],curr[1],id-curr[2]});
            }

            if(l != -1 and r != -1){
                active.insert({l,r,id});
            }
            else if(l != -1){
                active.insert({l,i,id});
            }
            else if(r != -1){
                active.insert({i,r,id});
            }
            else{
                active.insert({i,i,id});
            }
        }
    }

    sort(all(queries));
    sort(all(segs));
    
    fenwick<int> fenw(n+5);
    int ptr = 0;

    vector<int> ans(q+5,-1);

    for(auto [l,r,id] : queries){
        while(ptr < sz(segs) and segs[ptr][0] <= l){
            auto [lx,rx,wx] = segs[ptr];
            fenw.pupd(rx,wx);
            ptr++;
        }

        ans[id] = fenw.query(r,n);

        auto it = get_seg(l);

        {
            auto [lx,rx,t] = *it;
            if(lx <= l and rx >= r){
                ans[id] += id-t;
            }
        }
    }

    rep1(i,q){
        if(ans[i] != -1){
            cout << ans[i] << endl;
        }
    }

    /*

    rep1(id,q){
        string t; cin >> t;
        if(t == "toggle"){
            int i; cin >> i;
            a[i] ^= 1;

            if(!a[i]){
                // unset
                auto it = get_seg(i);
                assert(it != active.end());
                auto [l,r,t] = *it;
                segs.pb({l,r,id-t});
                active.erase(it);

                if(l <= i-1){
                    active.insert({l,i-1,id});
                }
                if(i+1 <= r){
                    active.insert({i+1,r,id});
                }
            }
            else{
                // set
                auto it1 = get_seg(i-1);
                auto it2 = get_seg(i+1);
                
                int l = -1, r = -1;

                if(it1 != active.end()){
                    auto curr = *it1;
                    active.erase(it1);
                    l = curr[0];                    
                    segs.pb({curr[0],curr[1],id-curr[2]});
                }

                if(it2 != active.end()){
                    auto curr = *it2;
                    active.erase(it2);
                    r = curr[1];
                    segs.pb({curr[0],curr[1],id-curr[2]});
                }

                if(l != -1 and r != -1){
                    active.insert({l,r,id});
                }
                else if(l != -1){
                    active.insert({l,i,id});
                }
                else if(r != -1){
                    active.insert({i,r,id});
                }
                else{
                    active.insert({i,i,id});
                }
            }
        }
        else{
            int l,r; cin >> l >> r;
            r--;
            
            auto it = get_seg(l);
            int ans = 0;

            {
                auto [lx,rx,t] = *it;
                if(lx <= l and rx >= r){
                    ans += id-t;
                }
            }

            for(auto [lx,rx,wx] : segs){
                if(lx <= l and rx >= r){
                    ans += wx;
                }
            }

            cout << ans << endl;
        }
    }

    */
}

int main()
{
    fastio;

    int t = 1;
    // cin >> t;

    rep1(i, t) {
        solve(i);
    }

    return 0;
}

Compilation message (stderr)

street_lamps.cpp: In function 'void solve(int)':
street_lamps.cpp:240:19: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::array<int, 3> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  240 |         while(ptr < sz(segs) and segs[ptr][0] <= l){
      |                   ^

• Subtask 1: 0 / 20
• Subtask 2: 0 / 20
• Subtask 3: 0 / 20
• Subtask 4: 20 / 20
• Subtask 5: 0 / 20