oj.uz

Submission #391788

# Submission time Handle Problem Language Result Execution time Memory
391788 2021-04-19T20:16:28 Z MarcoMeijer Land of the Rainbow Gold (APIO17_rainbow) C++14
35 / 100
 3000 ms 62984 KB 
#include "rainbow.h"
#include <bits/stdc++.h>
using namespace std;

// macros
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<ll, ll> lll;
typedef tuple<int, int, int> iii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<iii> viii;
typedef vector<ll> vll;
typedef vector<lll> vlll;
#define REP(a,b,c) for(int a=int(b); a<int(c); a++)
#define RE(a,c) REP(a,0,c)
#define RE1(a,c) REP(a,1,c+1)
#define REI(a,b,c) REP(a,b,c+1)
#define REV(a,b,c) for(int a=int(c-1); a>=int(b); a--)
#define FOR(a,b) for(auto& a : b)
#define all(a) a.begin(), a.end()
#define INF 1e9
#define EPS 1e-9
#define pb push_back
#define popb pop_back
#define fi first
#define se second
#define sz size()

const int MX = (1<<22);
const int N = (1<<19);

int R, C, sr, sc, m;
set<ii> blue;
set<ii> points;
set<ii> edges;
int minR, maxR, minC, maxC;

struct QuadTree {
    int pointX[MX][5];
    int pointY[MX][5];
    int tot[MX];
    int child[MX][4];
    int nxt=1;
    QuadTree() {
        RE(i,N) tot[i]=0;
        RE(i,N) RE(j,4) child[i][j] = -1;
    }

    void add(int x, int y, int l=0, int r=N-1, int u=0, int d=N-1, int p=0) {
        tot[p]++;
        if(tot[p] <= 5) {
            pointX[p][tot[p]-1] = x;
            pointY[p][tot[p]-1] = y;
            return;
        }
        if(l == r)
            return;
        int mh = (l+r)/2;
        int mv = (u+d)/2;
        int cd = 0;
        if(x <= mh) cd += 1, r=mh;
        else l=mh+1;
        if(y <= mv) cd += 2, d=mv;
        else u=mv+1;
        if(child[p][cd] == -1) child[p][cd] = nxt++;
        add(x,y,l,r,u,d,child[p][cd]);
    }
    int get(int a, int b, int x, int y, int l=0, int r=N-1, int u=0, int d=N-1, int p=0) {
        if(p == -1) return 0;
        if(b < l || a > r || y < u || x > d) return 0;
        if(a <= l && b >= r && x <= u && y >= d) return tot[p];
        int res = 0;
        RE(i,min(5,tot[p]))
            if(a <= pointX[p][i] && pointX[p][i] <= b && x <= pointY[p][i] && pointY[p][i] <= y)
                res++;
        if(tot[p] <= 5)
            return res;
        int mh = (l+r)/2;
        int mv = (u+d)/2;
        res += get(a,b,x,y, mh+1, r , mv+1, d , child[p][0]);
        res += get(a,b,x,y, l   , mh, mv+1, d , child[p][1]);
        res += get(a,b,x,y, mh+1, r , u   , mv, child[p][2]);
        res += get(a,b,x,y, l   , mh, u   , mv, child[p][3]);
        return res;
    }
} blueCells, bluePoints, blueLandEdgesH, blueLandEdgesV;

void init(int _R, int _C, int _sr, int _sc, int M, char *S) {
    R=_R; C=_C; sr=_sr; sc=_sc;
    minR=maxR=sr;
    minC=maxC=sc;
    RE(i,M) {
        blue.insert({sc,sr});
        if(S[i] == 'N') sr--;
        if(S[i] == 'S') sr++;
        if(S[i] == 'E') sc++;
        if(S[i] == 'W') sc--;
    }
    blue.insert({sc,sr});

    FOR(p,blue) {
        minR = min(minR, p.se);
        minC = min(minC, p.fi);
        maxR = max(maxR, p.se);
        maxC = max(maxC, p.fi);
        blueCells.add(p.fi,p.se);
        points.insert({p.fi  ,p.se  });
        points.insert({p.fi  ,p.se+1});
        points.insert({p.fi+1,p.se  });
        points.insert({p.fi+1,p.se+1});

        if(!blue.count({p.fi-1,p.se  })) blueLandEdgesV.add(p.fi  , p.se  );
                                         blueLandEdgesV.add(p.fi+1, p.se  );
        if(!blue.count({p.fi  ,p.se-1})) blueLandEdgesH.add(p.fi  , p.se  );
                                         blueLandEdgesH.add(p.fi  , p.se+1);
    }

    FOR(p,points)
        bluePoints.add(p.fi,p.se);
}

int colour(int ar, int ac, int br, int bc) {
    int blueCellsCnt  = blueCells .get(ac  ,bc,ar  ,br);
    int bluePointsCnt = bluePoints.get(ac+1,bc,ar+1,br);
    int blueLandEdges = blueLandEdgesH.get(ac,bc,ar+1,br) + blueLandEdgesV.get(ac+1,bc,ar,br);
    int W = bc - ac + 1;
    int H = br - ar + 1;
    int V = W*H - blueCellsCnt;
    int F = (W-1)*(H-1) - bluePointsCnt + 1;
    int E = (W-1)*H + (H-1)*W - blueLandEdges;

    if(ar < minR && maxR < br && ac < minC && maxC < bc)
        F++;

    return V - E + F - 1;
}

Compilation message

rainbow.cpp: In function 'void init(int, int, int, int, int, char*)':
rainbow.cpp:114:9: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  114 |         if(!blue.count({p.fi-1,p.se  })) blueLandEdgesV.add(p.fi  , p.se  );
      |         ^~
rainbow.cpp:115:42: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  115 |                                          blueLandEdgesV.add(p.fi+1, p.se  );
      |                                          ^~~~~~~~~~~~~~
rainbow.cpp:116:9: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  116 |         if(!blue.count({p.fi  ,p.se-1})) blueLandEdgesH.add(p.fi  , p.se  );
      |         ^~
rainbow.cpp:117:42: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  117 |                                          blueLandEdgesH.add(p.fi  , p.se+1);
      |                                          ^~~~~~~~~~~~~~

Subtask #1
11.0 / 11.0

# Verdict Execution time Memory Grader output
1 Correct 27 ms 41420 KB Output is correct
2 Correct 31 ms 41636 KB Output is correct
3 Correct 27 ms 41508 KB Output is correct
4 Correct 27 ms 41480 KB Output is correct
5 Correct 32 ms 41540 KB Output is correct
6 Correct 25 ms 41352 KB Output is correct
7 Correct 22 ms 41452 KB Output is correct
8 Correct 22 ms 41420 KB Output is correct
9 Correct 22 ms 41404 KB Output is correct
10 Correct 25 ms 41444 KB Output is correct
11 Correct 28 ms 41536 KB Output is correct
12 Correct 31 ms 41540 KB Output is correct
13 Correct 35 ms 41724 KB Output is correct
14 Correct 37 ms 41756 KB Output is correct
15 Correct 23 ms 41412 KB Output is correct
16 Correct 21 ms 41424 KB Output is correct
17 Correct 24 ms 41476 KB Output is correct

Subtask #2
0 / 12.0

# Verdict Execution time Memory Grader output
1 Correct 21 ms 41424 KB Output is correct
2 Correct 24 ms 41476 KB Output is correct
3 Execution timed out 3050 ms 53748 KB Time limit exceeded
4 Halted 0 ms 0 KB -

Subtask #3
24.0 / 24.0

# Verdict Execution time Memory Grader output
1 Correct 23 ms 41412 KB Output is correct
2 Correct 205 ms 61416 KB Output is correct
3 Correct 218 ms 61356 KB Output is correct
4 Correct 211 ms 62984 KB Output is correct
5 Correct 166 ms 56444 KB Output is correct
6 Correct 67 ms 45508 KB Output is correct
7 Correct 101 ms 49368 KB Output is correct
8 Correct 163 ms 59872 KB Output is correct
9 Correct 156 ms 57668 KB Output is correct
10 Correct 58 ms 45684 KB Output is correct
11 Correct 106 ms 51520 KB Output is correct
12 Correct 204 ms 61444 KB Output is correct
13 Correct 213 ms 61388 KB Output is correct
14 Correct 218 ms 62940 KB Output is correct
15 Correct 174 ms 56524 KB Output is correct
16 Correct 57 ms 44612 KB Output is correct
17 Correct 103 ms 49380 KB Output is correct
18 Correct 205 ms 62528 KB Output is correct
19 Correct 214 ms 61636 KB Output is correct
20 Correct 226 ms 61580 KB Output is correct
21 Correct 167 ms 59884 KB Output is correct
22 Correct 162 ms 57704 KB Output is correct
23 Correct 58 ms 45636 KB Output is correct
24 Correct 122 ms 51396 KB Output is correct
25 Correct 205 ms 61508 KB Output is correct
26 Correct 220 ms 61432 KB Output is correct
27 Correct 211 ms 62888 KB Output is correct
28 Correct 160 ms 56436 KB Output is correct
29 Correct 57 ms 44644 KB Output is correct
30 Correct 104 ms 49300 KB Output is correct
31 Correct 201 ms 62660 KB Output is correct
32 Correct 219 ms 61532 KB Output is correct
33 Correct 221 ms 61544 KB Output is correct

Subtask #4
0 / 27.0

# Verdict Execution time Memory Grader output
1 Correct 27 ms 41420 KB Output is correct
2 Correct 31 ms 41636 KB Output is correct
3 Correct 27 ms 41508 KB Output is correct
4 Correct 27 ms 41480 KB Output is correct
5 Correct 32 ms 41540 KB Output is correct
6 Correct 25 ms 41352 KB Output is correct
7 Correct 22 ms 41452 KB Output is correct
8 Correct 22 ms 41420 KB Output is correct
9 Correct 22 ms 41404 KB Output is correct
10 Correct 25 ms 41444 KB Output is correct
11 Correct 28 ms 41536 KB Output is correct
12 Correct 31 ms 41540 KB Output is correct
13 Correct 35 ms 41724 KB Output is correct
14 Correct 37 ms 41756 KB Output is correct
15 Correct 23 ms 41412 KB Output is correct
16 Correct 21 ms 41424 KB Output is correct
17 Correct 24 ms 41476 KB Output is correct
18 Execution timed out 3071 ms 52344 KB Time limit exceeded
19 Halted 0 ms 0 KB -

Subtask #5
0 / 26.0

# Verdict Execution time Memory Grader output
1 Correct 27 ms 41420 KB Output is correct
2 Correct 31 ms 41636 KB Output is correct
3 Correct 27 ms 41508 KB Output is correct
4 Correct 27 ms 41480 KB Output is correct
5 Correct 32 ms 41540 KB Output is correct
6 Correct 25 ms 41352 KB Output is correct
7 Correct 22 ms 41452 KB Output is correct
8 Correct 22 ms 41420 KB Output is correct
9 Correct 22 ms 41404 KB Output is correct
10 Correct 25 ms 41444 KB Output is correct
11 Correct 28 ms 41536 KB Output is correct
12 Correct 31 ms 41540 KB Output is correct
13 Correct 35 ms 41724 KB Output is correct
14 Correct 37 ms 41756 KB Output is correct
15 Correct 23 ms 41412 KB Output is correct
16 Correct 21 ms 41424 KB Output is correct
17 Correct 24 ms 41476 KB Output is correct
18 Execution timed out 3071 ms 52344 KB Time limit exceeded
19 Halted 0 ms 0 KB -