oj.uz

Submission #850172

# Submission time Handle Problem Language Result Execution time Memory
850172 2023-09-16T00:24:42 Z hngwlog Street Lamps (APIO19_street_lamps) C++14
80 / 100
 463 ms 41320 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';
            }
        }
    }
}

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();
    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 1 ms 344 KB Output is correct
2 Correct 1 ms 344 KB Output is correct
3 Correct 0 ms 344 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 1 ms 344 KB Output is correct
6 Correct 1 ms 348 KB Output is correct
7 Correct 1 ms 344 KB Output is correct

Subtask #2
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 65 ms 18516 KB Output is correct
2 Correct 68 ms 18768 KB Output is correct
3 Correct 70 ms 19408 KB Output is correct
4 Correct 80 ms 24088 KB Output is correct
5 Correct 80 ms 24568 KB Output is correct
6 Correct 77 ms 24288 KB Output is correct
7 Correct 85 ms 24804 KB Output is correct
8 Correct 88 ms 26340 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 344 KB Output is correct
4 Correct 1 ms 544 KB Output is correct
5 Correct 128 ms 24908 KB Output is correct
6 Correct 159 ms 25700 KB Output is correct
7 Correct 181 ms 26364 KB Output is correct
8 Correct 203 ms 28504 KB Output is correct
9 Correct 78 ms 15668 KB Output is correct
10 Correct 88 ms 16720 KB Output is correct
11 Correct 84 ms 16976 KB Output is correct
12 Correct 206 ms 27220 KB Output is correct
13 Correct 208 ms 28532 KB Output is correct

Subtask #4
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 344 KB Output is correct
2 Correct 1 ms 348 KB Output is correct
3 Correct 1 ms 348 KB Output is correct
4 Correct 2 ms 344 KB Output is correct
5 Correct 204 ms 39684 KB Output is correct
6 Correct 249 ms 39332 KB Output is correct
7 Correct 312 ms 39616 KB Output is correct
8 Correct 463 ms 41320 KB Output is correct
9 Correct 160 ms 22460 KB Output is correct
10 Correct 155 ms 25540 KB Output is correct
11 Correct 161 ms 22468 KB Output is correct
12 Correct 150 ms 24920 KB Output is correct
13 Correct 169 ms 22560 KB Output is correct
14 Correct 151 ms 24516 KB Output is correct
15 Correct 201 ms 27212 KB Output is correct
16 Correct 207 ms 28648 KB Output is correct

Subtask #5
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 0 ms 344 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 1 ms 344 KB Output is correct
6 Correct 1 ms 348 KB Output is correct
7 Correct 1 ms 344 KB Output is correct
8 Correct 65 ms 18516 KB Output is correct
9 Correct 68 ms 18768 KB Output is correct
10 Correct 70 ms 19408 KB Output is correct
11 Correct 80 ms 24088 KB Output is correct
12 Correct 80 ms 24568 KB Output is correct
13 Correct 77 ms 24288 KB Output is correct
14 Correct 85 ms 24804 KB Output is correct
15 Correct 88 ms 26340 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 344 KB Output is correct
19 Correct 1 ms 544 KB Output is correct
20 Correct 128 ms 24908 KB Output is correct
21 Correct 159 ms 25700 KB Output is correct
22 Correct 181 ms 26364 KB Output is correct
23 Correct 203 ms 28504 KB Output is correct
24 Correct 78 ms 15668 KB Output is correct
25 Correct 88 ms 16720 KB Output is correct
26 Correct 84 ms 16976 KB Output is correct
27 Correct 206 ms 27220 KB Output is correct
28 Correct 208 ms 28532 KB Output is correct
29 Correct 2 ms 344 KB Output is correct
30 Correct 1 ms 348 KB Output is correct
31 Correct 1 ms 348 KB Output is correct
32 Correct 2 ms 344 KB Output is correct
33 Correct 204 ms 39684 KB Output is correct
34 Correct 249 ms 39332 KB Output is correct
35 Correct 312 ms 39616 KB Output is correct
36 Correct 463 ms 41320 KB Output is correct
37 Correct 160 ms 22460 KB Output is correct
38 Correct 155 ms 25540 KB Output is correct
39 Correct 161 ms 22468 KB Output is correct
40 Correct 150 ms 24920 KB Output is correct
41 Correct 169 ms 22560 KB Output is correct
42 Correct 151 ms 24516 KB Output is correct
43 Correct 201 ms 27212 KB Output is correct
44 Correct 207 ms 28648 KB Output is correct
45 Incorrect 28 ms 11600 KB Output isn't correct
46 Halted 0 ms 0 KB -