oj.uz

Submission #876910

# Submission time Handle Problem Language Result Execution time Memory
876910 2023-11-22T13:35:00 Z marvinthang Land of the Rainbow Gold (APIO17_rainbow) C++17
50 / 100
 593 ms 1048576 KB 
/*************************************
*    author: marvinthang             *
*    created: 22.11.2023 16:30:03    *
*************************************/
 
#include "rainbow.h"
#include <bits/stdc++.h>
 
using namespace std;
 
#define                  fi  first
#define                  se  second
#define                left  ___left
#define               right  ___right
#define                TIME  (1.0 * clock() / CLOCKS_PER_SEC)
#define             MASK(i)  (1LL << (i))
#define           BIT(x, i)  ((x) >> (i) & 1)
#define  __builtin_popcount  __builtin_popcountll
#define              ALL(v)  (v).begin(), (v).end()
#define           REP(i, n)  for (int i = 0, _n = (n); i < _n; ++i)
#define          REPD(i, n)  for (int i = (n); i-- > 0; )
#define        FOR(i, a, b)  for (int i = (a), _b = (b); i < _b; ++i) 
#define       FORD(i, b, a)  for (int i = (b), _a = (a); --i >= _a; ) 
#define       FORE(i, a, b)  for (int i = (a), _b = (b); i <= _b; ++i) 
#define      FORDE(i, b, a)  for (int i = (b), _a = (a); i >= _a; --i) 
#define        scan_op(...)  istream & operator >> (istream &in, __VA_ARGS__ &u)
#define       print_op(...)  ostream & operator << (ostream &out, const __VA_ARGS__ &u)
#ifdef LOCAL
    #include "debug.h"
#else
    #define file(name) if (fopen(name".inp", "r")) { freopen(name".inp", "r", stdin); freopen(name".out", "w", stdout); }
    #define DB(...) 23
    #define db(...) 23
    #define debug(...) 23
#endif
 
template <class U, class V> scan_op(pair <U, V>)  { return in >> u.first >> u.second; }
template <class T> scan_op(vector <T>)  { for (size_t i = 0; i < u.size(); ++i) in >> u[i]; return in; }
template <class U, class V> print_op(pair <U, V>)  { return out << '(' << u.first << ", " << u.second << ')'; }
template <size_t i, class T> ostream & print_tuple_utils(ostream &out, const T &tup) { if constexpr(i == tuple_size<T>::value) return out << ")";  else return print_tuple_utils<i + 1, T>(out << (i ? ", " : "(") << get<i>(tup), tup); }
template <class ...U> print_op(tuple<U...>) { return print_tuple_utils<0, tuple<U...>>(out, u); }
template <class Con, class = decltype(begin(declval<Con>()))> typename enable_if <!is_same<Con, string>::value, ostream&>::type operator << (ostream &out, const Con &con) { out << '{'; for (__typeof(con.begin()) it = con.begin(); it != con.end(); ++it) out << (it == con.begin() ? "" : ", ") << *it; return out << '}'; }
 
struct Node {
    int cnt;
    Node *left, *right;
    Node(int v = 0): cnt(v), left(nullptr), right(nullptr) {}
    Node(Node *l, Node *r) {
        left = l, right = r;
        cnt = l->cnt + r->cnt;
    }
};
 
Node* build(int l, int r) {
    if (r - l == 1) return new Node(0);
    int m = l + r >> 1;
    return new Node(build(l, m), build(m, r));
}
Node* upgrade(Node *cur, int l, int r, int p, int v) {
    if (r - l == 1) return new Node(cur->cnt + v);
    int m = l + r >> 1;
    if (p < m) return new Node(upgrade(cur->left, l, m, p, v), cur->right);
    return new Node(cur->left, upgrade(cur->right, m, r, p, v));
};
int get_sum(Node *p, Node *q, int l, int r, int u, int v) {
    if (l >= v || r <= u) return 0;
    if (u <= l && r <= v) return q->cnt - p->cnt;
    int m = l + r >> 1;
    return get_sum(p->left, q->left, l, m, u, v) + get_sum(p->right, q->right, m, r, u, v);
}
 
vector <Node *> drow, dcol, dsquare, dcell;
 
int R, C;
vector <vector <bool>> board;
vector <vector <int>> rows, cols;
 
void init(int r, int c, int sr, int sc, int M, char *S) {
    R = r; C = c; --sr; --sc;
 
    rows.resize(R);
    cols.resize(C);
    board.assign(R, vector<bool>(C));
    drow.push_back(build(0, C));
    dcol.push_back(build(0, R));
    dsquare.push_back(build(0, C));
    dcell.push_back(build(0, C));
 
    board[sr][sc] = true;
    rows[sr].push_back(sc);
    cols[sc].push_back(sr);
 
    REP(i, M) {
        if (S[i] == 'N') --sr;
        else if (S[i] == 'S') ++sr;
        else if (S[i] == 'W') --sc;
        else ++sc;
        board[sr][sc] = true;
        rows[sr].push_back(sc);
        cols[sc].push_back(sr);
    }
    vector <bool> exist(C);
    REP(r, R) {
        if (r) {
            drow.push_back(drow.back());
            dsquare.push_back(dsquare.back());
        }
        dcell.push_back(dcell.back());
 
        sort(ALL(rows[r]));
        rows[r].erase(unique(ALL(rows[r])), rows[r].end());
        int last = -2;
        REP(i, rows[r].size()) {
            int c = rows[r][i];
            dcell.back() = upgrade(dcell.back(), 0, C, c, 1);
            int add = 0;
            if (exist[c]) {
                drow.back() = upgrade(drow.back(), 0, C, c, 1);
                if (last + 1 == c && exist[c - 1]) dsquare.back() = upgrade(dsquare.back(), 0, C, c, -1);
            } else {
                if (c && last + 1 != c && exist[c - 1]) dsquare.back() = upgrade(dsquare.back(), 0, C, c, +1);
                if (c + 1 < C && exist[c + 1] && (i + 1 == (int) rows[r].size() || rows[r][i + 1] != c + 1)) 
                    dsquare.back() = upgrade(dsquare.back(), 0, C, c + 1, +1);
            }
            last = c;
        }
        if (r) for (int c: rows[r - 1]) exist[c] = false;
        for (int c: rows[r]) exist[c] = true;
 
    }
    exist.assign(R, false);
    REP(c, C) {
        if (c) dcol.push_back(dcol.back());
        sort(ALL(cols[c]));
        cols[c].erase(unique(ALL(cols[c])), cols[c].end());
        for (int r: cols[c]) if (exist[r]) dcol.back() = upgrade(dcol.back(), 0, R, r, 1);
        if (c) for (int r: cols[c - 1]) exist[r] = false;
        for (int r: cols[c]) exist[r] = true;
    }
}
 
bool exist(int x, int y) {
    return binary_search(ALL(rows[x]), y);
}
 
int colour(int ar, int ac, int br, int bc) {
    --ar; --ac; --br; --bc;
    int cnt_cell = get_sum(dcell[ar], dcell[br + 1], 0, C, ac, bc + 1);
    if (!cnt_cell) return 1;
    int cnt_border = 0;
    int res = 1 - exist(ar, ac) - exist(ar, bc) - exist(br, ac) - exist(br, bc);
    res += get_sum(drow[ar], drow[br], 0, C, ac, bc + 1);
    res += get_sum(dcol[ac], dcol[bc], 0, R, ar, br + 1);
    for (int c: {ac, bc}) {
        cnt_border += upper_bound(ALL(cols[c]), br) - lower_bound(ALL(cols[c]), ar);
        res -= get_sum(drow[ar], drow[br], 0, C, c, c + 1);
    }
    for (int r: {ar, br}) {
        cnt_border += upper_bound(ALL(rows[r]), bc) - lower_bound(ALL(rows[r]), ac);
        res -= get_sum(dcol[ac], dcol[bc], 0, R, r, r + 1);
    }
    res += get_sum(dsquare[ar], dsquare[br], 0, C, ac + 1, bc + 1);
    return cnt_border - cnt_cell + res + !cnt_border;
}

Compilation message

rainbow.cpp: In function 'Node* build(int, int)':
rainbow.cpp:56:15: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   56 |     int m = l + r >> 1;
      |             ~~^~~
rainbow.cpp: In function 'Node* upgrade(Node*, int, int, int, int)':
rainbow.cpp:61:15: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   61 |     int m = l + r >> 1;
      |             ~~^~~
rainbow.cpp: In function 'int get_sum(Node*, Node*, int, int, int, int)':
rainbow.cpp:68:15: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   68 |     int m = l + r >> 1;
      |             ~~^~~
rainbow.cpp: In function 'void init(int, int, int, int, int, char*)':
rainbow.cpp:116:17: warning: unused variable 'add' [-Wunused-variable]
  116 |             int add = 0;
      |                 ^~~

Subtask #1
11.0 / 11.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 344 KB Output is correct
2 Correct 2 ms 860 KB Output is correct
3 Correct 1 ms 348 KB Output is correct
4 Correct 1 ms 604 KB Output is correct
5 Correct 2 ms 1116 KB Output is correct
6 Correct 0 ms 348 KB Output is correct
7 Correct 1 ms 348 KB Output is correct
8 Correct 0 ms 348 KB Output is correct
9 Correct 0 ms 348 KB Output is correct
10 Correct 0 ms 344 KB Output is correct
11 Correct 2 ms 604 KB Output is correct
12 Correct 2 ms 856 KB Output is correct
13 Correct 2 ms 860 KB Output is correct
14 Correct 3 ms 1372 KB Output is correct
15 Correct 0 ms 348 KB Output is correct
16 Correct 0 ms 344 KB Output is correct
17 Correct 0 ms 348 KB Output is correct

Subtask #2
12.0 / 12.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 405 ms 87684 KB Output is correct
4 Correct 593 ms 117240 KB Output is correct
5 Correct 558 ms 121404 KB Output is correct
6 Correct 451 ms 137440 KB Output is correct
7 Correct 450 ms 111552 KB Output is correct
8 Correct 275 ms 48852 KB Output is correct
9 Correct 510 ms 117268 KB Output is correct
10 Correct 542 ms 121072 KB Output is correct
11 Correct 478 ms 137104 KB Output is correct
12 Correct 189 ms 111432 KB Output is correct
13 Correct 205 ms 117344 KB Output is correct
14 Correct 212 ms 121152 KB Output is correct
15 Correct 222 ms 137276 KB Output is correct
16 Correct 423 ms 96048 KB Output is correct

Subtask #3
0 / 24.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 348 KB Output is correct
2 Runtime error 548 ms 1048576 KB Execution killed with signal 9
3 Halted 0 ms 0 KB -

Subtask #4
27.0 / 27.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 344 KB Output is correct
2 Correct 2 ms 860 KB Output is correct
3 Correct 1 ms 348 KB Output is correct
4 Correct 1 ms 604 KB Output is correct
5 Correct 2 ms 1116 KB Output is correct
6 Correct 0 ms 348 KB Output is correct
7 Correct 1 ms 348 KB Output is correct
8 Correct 0 ms 348 KB Output is correct
9 Correct 0 ms 348 KB Output is correct
10 Correct 0 ms 344 KB Output is correct
11 Correct 2 ms 604 KB Output is correct
12 Correct 2 ms 856 KB Output is correct
13 Correct 2 ms 860 KB Output is correct
14 Correct 3 ms 1372 KB Output is correct
15 Correct 0 ms 348 KB Output is correct
16 Correct 0 ms 344 KB Output is correct
17 Correct 0 ms 348 KB Output is correct
18 Correct 296 ms 40748 KB Output is correct
19 Correct 81 ms 5712 KB Output is correct
20 Correct 70 ms 3868 KB Output is correct
21 Correct 66 ms 4240 KB Output is correct
22 Correct 67 ms 4576 KB Output is correct
23 Correct 74 ms 5464 KB Output is correct
24 Correct 85 ms 4424 KB Output is correct
25 Correct 78 ms 4656 KB Output is correct
26 Correct 69 ms 4884 KB Output is correct
27 Correct 191 ms 58424 KB Output is correct
28 Correct 187 ms 35696 KB Output is correct
29 Correct 220 ms 65052 KB Output is correct
30 Correct 266 ms 74212 KB Output is correct
31 Correct 3 ms 344 KB Output is correct
32 Correct 322 ms 45136 KB Output is correct

Subtask #5
0 / 26.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 344 KB Output is correct
2 Correct 2 ms 860 KB Output is correct
3 Correct 1 ms 348 KB Output is correct
4 Correct 1 ms 604 KB Output is correct
5 Correct 2 ms 1116 KB Output is correct
6 Correct 0 ms 348 KB Output is correct
7 Correct 1 ms 348 KB Output is correct
8 Correct 0 ms 348 KB Output is correct
9 Correct 0 ms 348 KB Output is correct
10 Correct 0 ms 344 KB Output is correct
11 Correct 2 ms 604 KB Output is correct
12 Correct 2 ms 856 KB Output is correct
13 Correct 2 ms 860 KB Output is correct
14 Correct 3 ms 1372 KB Output is correct
15 Correct 0 ms 348 KB Output is correct
16 Correct 0 ms 344 KB Output is correct
17 Correct 0 ms 348 KB Output is correct
18 Correct 296 ms 40748 KB Output is correct
19 Correct 81 ms 5712 KB Output is correct
20 Correct 70 ms 3868 KB Output is correct
21 Correct 66 ms 4240 KB Output is correct
22 Correct 67 ms 4576 KB Output is correct
23 Correct 74 ms 5464 KB Output is correct
24 Correct 85 ms 4424 KB Output is correct
25 Correct 78 ms 4656 KB Output is correct
26 Correct 69 ms 4884 KB Output is correct
27 Correct 191 ms 58424 KB Output is correct
28 Correct 187 ms 35696 KB Output is correct
29 Correct 220 ms 65052 KB Output is correct
30 Correct 266 ms 74212 KB Output is correct
31 Correct 3 ms 344 KB Output is correct
32 Correct 322 ms 45136 KB Output is correct
33 Runtime error 548 ms 1048576 KB Execution killed with signal 9
34 Halted 0 ms 0 KB -