oj.uz

Submission #851001

# Submission time Handle Problem Language Result Execution time Memory
851001 2023-09-18T07:26:48 Z hngwlog Street Lamps (APIO19_street_lamps) C++14
100 / 100
 779 ms 126964 KB 
#include <bits/stdc++.h>
using namespace std;

#define fi first
#define se second
#define _size(x) (int)x.size()
#define BIT(i, x) ((x >> i) & 1)
#define MASK(n) ((1 << n) - 1)
#define REP(i, n) for (int i = 0, _n = (n); i < _n; i++)
#define FOR(i, a, b) for (int i = a, _b = (b); i <= _b; i++)
#define FORD(i, a, b) for (int i = a, _b = (b); i >= _b; i--)
#define FORB1(i, mask) for (int i = mask; i > 0; i ^= i & - i)
#define FORB0(i, n, mask) for (int i = ((1 << n) - 1) ^ mask; i > 0; i ^= i & - i)
#define FORALL(i, a) for (auto i: a)
#define fastio ios_base::sync_with_stdio(0); cin.tie(0);

struct queryNode {

    string type;
    int id, a, b;
};

int n, q;
string s;
vector<int> a;
vector<queryNode> qu;

namespace subtask1 {

    void main() {

        vector<vector<int>> c(q + 1, vector<int>(n + 1));
        FOR(i, 1, n) c[0][i] = a[i] + c[0][i - 1];
        REP(i, q) {
            FOR(j, 1, n) c[i + 1][j] = c[i][j] - c[i][j - 1];
            if (i && qu[i - 1].type == "toggle") c[i + 1][qu[i - 1].id] = 1 - c[i + 1][qu[i - 1].id];
            FOR(j, 1, n) c[i + 1][j] += c[i + 1][j - 1];
            if (qu[i].type == "query") {
                int a = qu[i].a, b = qu[i].b - 1;
                int ans = 0;
                FOR(j, 1, i + 1) ans += (c[j][b] - c[j][a - 1] == b - a + 1);
                cout << ans << '\n';
            }
        }
    }
}

bool checkSub2() {

    REP(i, q) {
        if (qu[i].type == "toggle") continue;
        if (qu[i].b - qu[i].a != 1) return false;
    }
    return true;
}

namespace subtask2 {

    void main() {

        vector<int> ans(n + 1), in(n + 1, - 1);
        FOR(i, 1, n) if (a[i] == 1) in[i] = 1;
        REP(i, q) {
            if (i && qu[i - 1].type == "toggle") {
                int id  = qu[i - 1].id;
                if (!a[id]) {
                    a[id] = 1 - a[id];
                    in[id] = i + 1;
                }
                else {
                    a[id] = 0;
                    ans[id] += (i + 1) - in[id];
                    in[id] = - 1;
                }
            }
            if (qu[i].type == "query") cout << ans[qu[i].a] + (in[qu[i].a] != - 1 ? i + 1 - in[qu[i].a] + 1 : 0) << '\n';
        }
    }
}

bool checkSub3() {

    vector<int> b(n + 1);
    FOR(i, 1, n) b[i] = a[i];
    REP(i, q) {
        if (qu[i].type == "toggle") {
            int id = qu[i].id;
            if (b[id]) return false;
            b[id] = 1 - b[id];
        }
    }
    return true;
}

namespace subtask3 {

    const int inf = 1e9;

    struct segTree {

        vector<int> ST;

        void init(int n) {

            ST.resize(4 * n + 4);
        }

        void update(int id, int l, int r, int pos, int val) {

            if (pos < l || r < pos) return ;
            if (l == r) {
                ST[id] = val;
                return ;
            }
            int mid = (l + r) / 2;
            update(id * 2, l, mid, pos, val);
            update(id * 2 + 1, mid + 1, r, pos, val);
            ST[id] = max(ST[id * 2], ST[id * 2 + 1]);
        }

        int get(int id, int l, int r, int u, int v) {

            if (r < u || v < l) return 0;
            if (u <= l && r <= v) return ST[id];
            int mid = (l + r) / 2;
            return max(get(id * 2, l, mid, u, v), get(id * 2 + 1, mid + 1, r, u, v));
        }
    } st;

    void main() {

        st.init(n);
        FOR(i, 1, n) {
            if (a[i]) st.update(1, 1, n, i, 1);
            else st.update(1, 1, n, i, inf);
        }
        REP(i, q) {
            if (qu[i].type == "toggle") {
                int id = qu[i].id;
                st.update(1, 1, n, id, i + 2);
            }
            if (qu[i].type == "query") {
                int a = qu[i].a, b = qu[i].b - 1;
                int value = st.get(1, 1, n, a, b);
                if (value == inf) cout << 0 << '\n';
                else cout << i + 1 - value + 1 << '\n';
            }
        }
    }
}

bool checkSub4() {

    int cnt = 0;
    REP(i, q) {
        if (qu[i].type == "toggle" && cnt) return false;
        cnt += (qu[i].type == "query");
    }
    return true;
}

namespace subtask4 {

    struct fenTree {

        int n;
        vector<int> bit;

        void init(int sz) {

            bit.resize(sz + 1);
            n = sz;
        }

        void update(int pos, int val) {

            while (pos <= n) {
                bit[pos] += val;
                pos += pos & - pos;
            }
        }

        int get(int pos) {

            int res = 0;
            while (pos) {
                res += bit[pos];
                pos -= pos & - pos;
            }
            return res;
        }
    } ft;

    void main() {

        map<pair<int, int>, int> in;
        set<int> st;
        int pos = - 1;
        FOR(i, 1, n) {
            if (!a[i]) {
                if (pos != - 1) {
                    in[{pos, i - 1}] = 1;
                    pos = - 1;
                }
                st.insert(i);
            }
            if (pos == - 1 && a[i]) pos = i;
        }
        if (pos) in[{pos, n}] = 1;
        vector<pair<pair<int, int>, int>> g;
        FOR(i, 1, q - 1) {
            if (qu[i - 1].type == "toggle") {
                int id = qu[i - 1].id;
                auto it = st.lower_bound(id);
                int l = - 1, r = - 1;
                if (it == st.end()) r = n;
                else r = *it - 1;
                if (it == st.begin()) l = 1;
                else {
                    it--;
                    l = *it + 1;
                }
                if (a[id]) {
                    g.push_back({{l, r}, i - in[{l, r}] + 1});
                    in.erase({l, r});
                    if (l <= id - 1) in[{l, id - 1}] = i + 1;
                    if (id + 1 <= r) in[{id + 1, r}] = i + 1;
                    st.insert(id);
                }
                else {
                    it = st.upper_bound(id);
                    if (it == st.end()) r = n;
                    else r = *it - 1;
                    if (l <= id - 1) {
                        g.push_back({{l, id - 1}, i - in[{l, id - 1}] + 1});
                        in.erase({l, id - 1});
                    }
                    if (id + 1 <= r) {
                        g.push_back({{id + 1, r}, i - in[{id + 1, r}] + 1});
                        in.erase({id + 1, r});
                    }
                    in[{l, r}] = i + 1;
                    st.erase(id);
                }
                a[id] = 1 - a[id];
            }
            if (qu[i].type == "query") break;
        }
        sort(g.begin(), g.end(), [&] (const pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) { return a.fi.fi < b.fi.fi; });
        vector<int> ask;
        REP(i, q) {
            if (qu[i].type == "toggle") continue;
            ask.push_back(i);
        }
        sort(ask.begin(), ask.end(), [&] (const int i, int j) { return qu[i].a < qu[j].a; });
        vector<int> ans(q);
        ft.init(n);
        int i = 0;
        FORALL(id, ask) {
            while (i < _size(g) && g[i].fi.fi <= qu[id].a) {
                ft.update(g[i].fi.se, g[i].se);
                i++;
            }
            ans[id] += ft.get(n) - ft.get(qu[id].b - 2);
        }
        vector<int> vtx;
        FOR(i, 1, n) if (!a[i]) vtx.push_back(i);
        int cnt = 0;
        REP(i, q) {
            if (qu[i].type == "toggle") continue;
            if (!_size(vtx)) cout << ans[i] + i + 1 - in[{1, n}] + 1 << '\n';
            else {
                pos = lower_bound(vtx.begin(), vtx.end(), qu[i].a) - vtx.begin();
                if (pos == _size(vtx) || vtx[pos] > qu[i].b - 1) {
                    int l = (pos > 0 ? vtx[pos - 1] + 1 : 1);
                    int r = (pos == _size(vtx) ? n : vtx[pos] - 1);
                    cout << ans[i] + i + 1 - in[{l, r}] + 1 << '\n';
                }
                else cout << ans[i] << '\n';
            }
        }
    }
}

namespace subtask5 {

    struct fenTree {

        int n;
        vector<int> bit;

        void init(int sz) {

            n = sz;
            bit.resize(n + 1);
        }

        void update(int pos, int val) {

            while (pos <= n) {
                bit[pos] += val;
                pos += pos & - pos;
            }
        }

        int get(int pos) {

            int res = 0;
            while (pos) {
                res += bit[pos];
                pos -= pos & - pos;
            }
            return res;
        }
    } ft;

    set<int> st;
    vector<int> ans;
    map<pair<int, int>, int> in;
    vector<vector<pair<pair<int, int>, int>>> adj;

    void dac(int v, int l, int r) {

        if (l == r) {
            if (qu[l].type == "query") {
                auto it = st.lower_bound(qu[l].a);
                if (it == st.end() || *it > qu[l].b - 1) {
                    int le = - 1, ri = - 1;
                    if (it == st.end()) ri = n;
                    else ri = *it - 1;
                    if (it == st.begin()) le = 1;
                    else {
                        it--;
                        le = *it + 1;
                    }
                    ans[l] += l + 1 - in[{le, ri}] + 1;
                }
                return ;
            }
            int id = qu[l].id;
            auto it = st.lower_bound(id);
            int le = - 1, ri = - 1;
            if (it == st.end()) ri = n;
            else ri = *it - 1;
            if (it == st.begin()) le = 1;
            else {
                it--;
                le = *it + 1;
            }
            if (a[id]) {
                adj[v].push_back({{le, ri}, l + 1 - in[{le, ri}] + 1});
                if (le <= id - 1) in[{le, id - 1}] = l + 2;
                if (id + 1 <= ri) in[{id + 1, ri}] = l + 2;
                st.insert(id);
            }
            else {
                it = st.upper_bound(id);
                if (it == st.end()) ri = n;
                else ri = *it - 1;
                if (le <= id - 1) adj[v].push_back({{le, id - 1}, l + 1 - in[{le, id - 1}] + 1});
                if (id + 1 <= ri) adj[v].push_back({{id + 1, ri}, l + 1 - in[{id + 1, ri}] + 1});
                in[{le, ri}] = l + 2;
                st.erase(id);
            }
            a[id] = 1 - a[id];
            return ;
        }
        int mid = (l + r) / 2;
        dac(v * 2, l, mid);
        vector<pair<pair<int, int>, int>> g = adj[v * 2];
        FOR(i, mid + 1, r) {
            if (qu[i].type == "toggle") continue;
            g.push_back({{qu[i].a, qu[i].b - 1}, - i});
        }
        sort(g.begin(), g.end(), [&] (const pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) { return a.fi.fi != b.fi.fi ? a.fi.fi < b.fi.fi : a.se > b.se; });
        FORALL(e, g) {
            if (e.se > 0) ft.update(n - e.fi.se + 1, e.se);
            else ans[- e.se] += ft.get(n - e.fi.se + 1);
        }
        FORALL(e, g) if (e.se > 0) ft.update(n - e.fi.se + 1, - e.se);
        dac(v * 2 + 1, mid + 1, r);
        FORALL(e, adj[v * 2]) adj[v].push_back(e);
        FORALL(e, adj[v * 2 + 1]) adj[v].push_back(e);
    }

    void main() {

        /***
            DAC
            moi nut duoc thuc hien toi da log n lan
            n log log
        */
        int pos = - 1;
        FOR(i, 1, n) {
            if (!a[i]) {
                if (pos != - 1) {
                    in[{pos, i - 1}] = 1;
                    pos = - 1;
                }
                st.insert(i);
            }
            if (pos == - 1 && a[i]) pos = i;
        }
        if (pos) in[{pos, n}] = 1;
        ft.init(n);
        ans.resize(q);
        adj.resize(4 * q + 4);
        dac(1, 0, q - 1);
        REP(i, q) if (qu[i].type == "query") cout << ans[i] << '\n';
    }
}

int main() {
    fastio;

    cin >> n >> q;
    cin >> s;
    a.resize(n + 1);
    FOR(i, 1, n) a[i] = s[i - 1] - '0';
    qu.resize(q);
    REP(i, q) {
        cin >> qu[i].type;
        if (qu[i].type == "toggle") cin >> qu[i].id;
        else cin >> qu[i].a >> qu[i].b;
    }
    if (n <= 100 && q <= 100) subtask1::main();
    else if (checkSub2()) subtask2::main();
    else if (checkSub3()) subtask3::main();
    else if (checkSub4()) subtask4::main();
    else subtask5::main();
    return 0;
}

Compilation message

street_lamps.cpp: In function 'void subtask4::main()':
street_lamps.cpp:268:13: warning: unused variable 'cnt' [-Wunused-variable]
  268 |         int cnt = 0;
      |             ^~~

Subtask #1
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 500 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 0 ms 348 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 1 ms 348 KB Output is correct
6 Correct 0 ms 348 KB Output is correct
7 Correct 0 ms 348 KB Output is correct

Subtask #2
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 63 ms 15320 KB Output is correct
2 Correct 65 ms 15440 KB Output is correct
3 Correct 68 ms 15328 KB Output is correct
4 Correct 83 ms 18944 KB Output is correct
5 Correct 89 ms 19428 KB Output is correct
6 Correct 68 ms 18956 KB Output is correct
7 Correct 79 ms 18948 KB Output is correct
8 Correct 82 ms 20452 KB Output is correct

Subtask #3
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 344 KB Output is correct
3 Correct 1 ms 524 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 134 ms 20820 KB Output is correct
6 Correct 151 ms 20832 KB Output is correct
7 Correct 174 ms 21068 KB Output is correct
8 Correct 206 ms 22628 KB Output is correct
9 Correct 73 ms 12624 KB Output is correct
10 Correct 84 ms 13732 KB Output is correct
11 Correct 82 ms 13648 KB Output is correct
12 Correct 201 ms 21400 KB Output is correct
13 Correct 205 ms 23052 KB Output is correct

Subtask #4
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 2 ms 348 KB Output is correct
3 Correct 1 ms 348 KB Output is correct
4 Correct 1 ms 344 KB Output is correct
5 Correct 201 ms 33392 KB Output is correct
6 Correct 289 ms 33896 KB Output is correct
7 Correct 325 ms 34372 KB Output is correct
8 Correct 423 ms 35904 KB Output is correct
9 Correct 159 ms 19248 KB Output is correct
10 Correct 155 ms 21440 KB Output is correct
11 Correct 157 ms 19176 KB Output is correct
12 Correct 148 ms 22724 KB Output is correct
13 Correct 157 ms 19136 KB Output is correct
14 Correct 152 ms 22724 KB Output is correct
15 Correct 204 ms 21184 KB Output is correct
16 Correct 205 ms 22656 KB Output is correct

Subtask #5
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 500 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 0 ms 348 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 1 ms 348 KB Output is correct
6 Correct 0 ms 348 KB Output is correct
7 Correct 0 ms 348 KB Output is correct
8 Correct 63 ms 15320 KB Output is correct
9 Correct 65 ms 15440 KB Output is correct
10 Correct 68 ms 15328 KB Output is correct
11 Correct 83 ms 18944 KB Output is correct
12 Correct 89 ms 19428 KB Output is correct
13 Correct 68 ms 18956 KB Output is correct
14 Correct 79 ms 18948 KB Output is correct
15 Correct 82 ms 20452 KB Output is correct
16 Correct 1 ms 344 KB Output is correct
17 Correct 1 ms 344 KB Output is correct
18 Correct 1 ms 524 KB Output is correct
19 Correct 1 ms 348 KB Output is correct
20 Correct 134 ms 20820 KB Output is correct
21 Correct 151 ms 20832 KB Output is correct
22 Correct 174 ms 21068 KB Output is correct
23 Correct 206 ms 22628 KB Output is correct
24 Correct 73 ms 12624 KB Output is correct
25 Correct 84 ms 13732 KB Output is correct
26 Correct 82 ms 13648 KB Output is correct
27 Correct 201 ms 21400 KB Output is correct
28 Correct 205 ms 23052 KB Output is correct
29 Correct 1 ms 344 KB Output is correct
30 Correct 2 ms 348 KB Output is correct
31 Correct 1 ms 348 KB Output is correct
32 Correct 1 ms 344 KB Output is correct
33 Correct 201 ms 33392 KB Output is correct
34 Correct 289 ms 33896 KB Output is correct
35 Correct 325 ms 34372 KB Output is correct
36 Correct 423 ms 35904 KB Output is correct
37 Correct 159 ms 19248 KB Output is correct
38 Correct 155 ms 21440 KB Output is correct
39 Correct 157 ms 19176 KB Output is correct
40 Correct 148 ms 22724 KB Output is correct
41 Correct 157 ms 19136 KB Output is correct
42 Correct 152 ms 22724 KB Output is correct
43 Correct 204 ms 21184 KB Output is correct
44 Correct 205 ms 22656 KB Output is correct
45 Correct 239 ms 61128 KB Output is correct
46 Correct 271 ms 64724 KB Output is correct
47 Correct 446 ms 75056 KB Output is correct
48 Correct 779 ms 126964 KB Output is correct
49 Correct 194 ms 51596 KB Output is correct
50 Correct 194 ms 51688 KB Output is correct
51 Correct 194 ms 51608 KB Output is correct
52 Correct 195 ms 52400 KB Output is correct
53 Correct 203 ms 52672 KB Output is correct
54 Correct 195 ms 53948 KB Output is correct