Submission #600091

# Submission time Handle Problem Language Result Execution time Memory
600091 2022-07-20T12:56:59 Z Valaki2 Fountain Parks (IOI21_parks) C++17
15 / 100
1248 ms 219616 KB
#include "parks.h"
#include <bits/stdc++.h>
using namespace std;

#define x X
#define y Y

#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define fi first
#define se second

const int maxn = 2e5;
const vector<pii > directions = {mp(-2, 0), mp(0, -2), mp(0, 2), mp(2, 0)};

bool check_possibility(int n, vector<int> x, vector<int> y) {
    unordered_map<int, unordered_map<int, bool> > m;
    unordered_map<int, unordered_map<int, int> > f;
    for(int i = 0; i < n; i++) {
        f[x[i]][y[i]] = i + 1;
    }
    queue<int> q;
    q.push(0);
    m[x[0]][y[0]] = true;
    int cnt = 0;
    while(!q.empty()) {
        int cur = q.front();
        q.pop();
        cnt++;
        for(pii dir : directions) {
            pii new_point = mp(x[cur] + dir.fi, y[cur] + dir.se);
            if(f[new_point.fi][new_point.se] && !m[new_point.fi][new_point.se]) {
                m[new_point.fi][new_point.se] = true;
                int new_id = f[new_point.fi][new_point.se] - 1;
                q.push(new_id);
            }
        }
    }
    return (cnt == n);
}

struct fountain {
    int x, y, id;
    fountain() : x(0), y(0), id(-1) {}
    fountain(int x_, int y_, int id_) :
        x(x_), y(y_), id(id_) {}
};

int n;
vector<fountain > points;
vector<int> x;
vector<int> y;
unordered_map<int, unordered_map<int, int> > fountain_at;

unordered_map<int, unordered_map<int, bool> > bench_at;
unordered_map<int, unordered_map<int, bool> > road_at;
vector<int> ans_u;
vector<int> ans_v;
vector<int> ans_a;
vector<int> ans_b;

void build_road_bench(int road_u, int road_v, pii bench_pos) {
    ans_u.pb(road_u);
    ans_v.pb(road_v);
    ans_a.pb(bench_pos.fi);
    ans_b.pb(bench_pos.se);
    bench_at[bench_pos.fi][bench_pos.se] = true;
    road_at[(points[road_u].x + points[road_v].x) / 2][(points[road_u].y + points[road_v].y) / 2] = true;
}

vector<pii> get_bench_locations_pii(pii a, pii b) {
    fountain f_a = fountain(a.fi, a.se, -1), f_b = fountain(b.fi, b.se, -1);
    if(f_a.x == f_b.x) {
        int new_y = (f_a.y + f_b.y) / 2;
        a = mp(f_a.x + 1, new_y), b = mp(f_a.x - 1, new_y);
    } else {
        int new_x = (f_a.x + f_b.x) / 2;
        a = mp(new_x, f_a.y + 1), b = mp(new_x, f_a.y - 1);
    }
    return {min(a, b), max(a, b)};
}

vector<pii> get_bench_locations(int a_idx, int b_idx) {
    fountain f_a = points[a_idx], f_b = points[b_idx];
    pii a, b;
    if(f_a.x == f_b.x) {
        int new_y = (f_a.y + f_b.y) / 2;
        a = mp(f_a.x + 1, new_y), b = mp(f_a.x - 1, new_y);
    } else {
        int new_x = (f_a.x + f_b.x) / 2;
        a = mp(new_x, f_a.y + 1), b = mp(new_x, f_a.y - 1);
    }
    return {min(a, b), max(a, b)};
}

int get_middle_of_intersection(int a_idx, int b_idx) {
    pii a = mp(points[a_idx].x, points[a_idx].y);
    pii b = mp(points[b_idx].x, points[b_idx].y);
    int cnt = 0;
    for(pii dir : directions) {
        pii nei = mp(a.fi + dir.fi, a.se + dir.se);
        if(fountain_at[nei.fi][nei.se]) {
            cnt++;
        }
    }
    if(cnt == 4) {
        return a_idx;
    }
    cnt = 0;
    for(pii dir : directions) {
        pii nei = mp(b.fi + dir.fi, b.se + dir.se);
        if(fountain_at[nei.fi][nei.se]) {
            cnt++;
        }
    }
    if(cnt == 4) {
        return b_idx;
    }
    return -1;
}

pii get_bench_when_in_intersection(int a_idx, int b_idx) {
    // a is the middle, b is a neighbour
    fountain a = points[a_idx], b = points[b_idx];
    if(b.x < a.x) {
        return mp(a.x - 1, a.y + 1);
    }
    if(b.y < a.y) {
        return mp(a.x - 1, a.y - 1);
    }
    if(b.y > a.y) {
        return mp(a.x + 1, a.y + 1);
    }
    if(b.x > a.x) {
        return mp(a.x + 1, a.y - 1);
    }
}

pii orig;
unordered_map<int, unordered_map<int, int> > not_bad;

bool bad_bench(pii bench, pii a, pii b) {
    int tmp = not_bad[bench.fi][bench.se];
    if(tmp == 1) {
        return false;
    }
    if(tmp == 2) {
        return true;
    }
    if(a > b) {
        swap(a, b);
    }
    vector<pii > v = {a, b};
    for(pii dir : directions) {
        pii other = mp(bench.fi + dir.fi, bench.se + dir.se);
        vector<pii> corners = get_bench_locations_pii(bench, other);
        if(corners != v) {
            if(fountain_at[corners[0].fi][corners[0].se] &&
                fountain_at[corners[1].fi][corners[1].se] &&
                //bench_at[other.fi][other.se] &&
                !road_at[(bench.fi + other.fi) / 2][(bench.se + other.se) / 2]) {
                if(other == orig) {
                    //not_bad[bench.fi][bench.se] = 1;
                    return false;
                }
                if(bench_at[other.fi][other.se]) {
                    //not_bad[bench.fi][bench.se] = 2;
                    return true;
                } else {
                    bool res = bad_bench(other, corners[0], corners[1]);
                    if(res) {
                        //not_bad[bench.fi][bench.se] = 2;
                    } else {
                        not_bad[bench.fi][bench.se] = 1;
                    }
                    return res;
                }
            }
        }
    }
    not_bad[bench.fi][bench.se] = 1;
    return false;
}

void solve() {
    unordered_map<int, unordered_map<int, bool> > vis;
    queue<int> q;
    q.push(0);
    vis[x[0]][y[0]] = true;
    while(!q.empty()) {
        int cur = q.front();
        q.pop();
        for(pii dir : directions) {
            pii new_point = mp(x[cur] + dir.fi, y[cur] + dir.se);
            if(fountain_at[new_point.fi][new_point.se] && !vis[new_point.fi][new_point.se]) {
                vis[new_point.fi][new_point.se] = true;
                int new_id = fountain_at[new_point.fi][new_point.se] - 1;
                q.push(new_id);
                int mid = get_middle_of_intersection(cur, new_id);
                if(mid != -1) {
                    build_road_bench(cur, new_id, get_bench_when_in_intersection(mid, cur ^ new_id ^ mid));
                } else {
                    vector<pii> benches = get_bench_locations(cur, new_id);
                    orig = benches[0];
                    if(!bench_at[benches[0].fi][benches[0].se] && !bad_bench(benches[0], mp(points[cur].x, points[cur].y), mp(points[new_id].x, points[new_id].y))) {
                        build_road_bench(cur, new_id, benches[0]);
                    } else {
                        build_road_bench(cur, new_id, benches[1]);
                    }
                }
            }
        }
    }
    //
}

#undef x
#undef y
int construct_roads(vector<int> x, vector<int> y) {
    // edge case
    if (x.size() == 1) {
        build({}, {}, {}, {});
        return 1;
    }
    // sample solution
    /*vector<int> u, v, a, b;
    u.push_back(0);
    v.push_back(1);
    a.push_back(x[0]+1);
    b.push_back(y[0]-1);
    build(u, v, a, b);*/
    n = x.size();
    if(!check_possibility(n, x, y)) {
        return 0;
    }
    X = x;
    Y = y;
    points.assign(n, fountain());
    for(int i = 0; i < n; i++) {
        points[i] = fountain(x[i], y[i], i);
        fountain_at[x[i]][y[i]] = i + 1;
    }
    solve();
    // build solution
    build(ans_u, ans_v, ans_a, ans_b);
    return 1;
}

/*
5
4 4
4 6
6 4
4 2
2 4
*/

Compilation message

parks.cpp: In function 'std::pair<int, int> get_bench_when_in_intersection(int, int)':
parks.cpp:138:1: warning: control reaches end of non-void function [-Wreturn-type]
  138 | }
      | ^
# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 289 ms 40832 KB Output is correct
10 Correct 19 ms 3924 KB Output is correct
11 Correct 110 ms 21284 KB Output is correct
12 Correct 32 ms 6060 KB Output is correct
13 Correct 29 ms 7204 KB Output is correct
14 Correct 1 ms 340 KB Output is correct
15 Correct 1 ms 468 KB Output is correct
16 Correct 274 ms 40876 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 289 ms 40832 KB Output is correct
10 Correct 19 ms 3924 KB Output is correct
11 Correct 110 ms 21284 KB Output is correct
12 Correct 32 ms 6060 KB Output is correct
13 Correct 29 ms 7204 KB Output is correct
14 Correct 1 ms 340 KB Output is correct
15 Correct 1 ms 468 KB Output is correct
16 Correct 274 ms 40876 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 0 ms 212 KB Output is correct
19 Correct 0 ms 212 KB Output is correct
20 Correct 1 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 706 ms 72676 KB Output is correct
24 Correct 1 ms 212 KB Output is correct
25 Correct 3 ms 724 KB Output is correct
26 Correct 2 ms 596 KB Output is correct
27 Correct 2 ms 596 KB Output is correct
28 Correct 250 ms 26508 KB Output is correct
29 Correct 395 ms 48168 KB Output is correct
30 Correct 506 ms 61692 KB Output is correct
31 Correct 654 ms 72876 KB Output is correct
32 Correct 0 ms 212 KB Output is correct
33 Correct 0 ms 212 KB Output is correct
34 Correct 0 ms 212 KB Output is correct
35 Correct 0 ms 212 KB Output is correct
36 Correct 0 ms 212 KB Output is correct
37 Correct 0 ms 212 KB Output is correct
38 Correct 1 ms 212 KB Output is correct
39 Correct 0 ms 212 KB Output is correct
40 Correct 0 ms 212 KB Output is correct
41 Correct 0 ms 212 KB Output is correct
42 Correct 1 ms 212 KB Output is correct
43 Correct 1 ms 468 KB Output is correct
44 Correct 2 ms 468 KB Output is correct
45 Correct 433 ms 36388 KB Output is correct
46 Correct 599 ms 53124 KB Output is correct
47 Correct 588 ms 53380 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 289 ms 40832 KB Output is correct
10 Correct 19 ms 3924 KB Output is correct
11 Correct 110 ms 21284 KB Output is correct
12 Correct 32 ms 6060 KB Output is correct
13 Correct 29 ms 7204 KB Output is correct
14 Correct 1 ms 340 KB Output is correct
15 Correct 1 ms 468 KB Output is correct
16 Correct 274 ms 40876 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 0 ms 212 KB Output is correct
19 Correct 0 ms 212 KB Output is correct
20 Correct 1 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 706 ms 72676 KB Output is correct
24 Correct 1 ms 212 KB Output is correct
25 Correct 3 ms 724 KB Output is correct
26 Correct 2 ms 596 KB Output is correct
27 Correct 2 ms 596 KB Output is correct
28 Correct 250 ms 26508 KB Output is correct
29 Correct 395 ms 48168 KB Output is correct
30 Correct 506 ms 61692 KB Output is correct
31 Correct 654 ms 72876 KB Output is correct
32 Correct 0 ms 212 KB Output is correct
33 Correct 0 ms 212 KB Output is correct
34 Correct 0 ms 212 KB Output is correct
35 Correct 0 ms 212 KB Output is correct
36 Correct 0 ms 212 KB Output is correct
37 Correct 0 ms 212 KB Output is correct
38 Correct 1 ms 212 KB Output is correct
39 Correct 0 ms 212 KB Output is correct
40 Correct 0 ms 212 KB Output is correct
41 Correct 0 ms 212 KB Output is correct
42 Correct 1 ms 212 KB Output is correct
43 Correct 1 ms 468 KB Output is correct
44 Correct 2 ms 468 KB Output is correct
45 Correct 433 ms 36388 KB Output is correct
46 Correct 599 ms 53124 KB Output is correct
47 Correct 588 ms 53380 KB Output is correct
48 Correct 0 ms 212 KB Output is correct
49 Correct 0 ms 212 KB Output is correct
50 Correct 0 ms 212 KB Output is correct
51 Incorrect 0 ms 212 KB Tree @(5, 5) appears more than once: for edges on positions 1 and 4
52 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 289 ms 40832 KB Output is correct
10 Correct 19 ms 3924 KB Output is correct
11 Correct 110 ms 21284 KB Output is correct
12 Correct 32 ms 6060 KB Output is correct
13 Correct 29 ms 7204 KB Output is correct
14 Correct 1 ms 340 KB Output is correct
15 Correct 1 ms 468 KB Output is correct
16 Correct 274 ms 40876 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 0 ms 212 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Correct 1248 ms 219616 KB Output is correct
21 Correct 1012 ms 128988 KB Output is correct
22 Correct 1111 ms 138372 KB Output is correct
23 Correct 799 ms 108184 KB Output is correct
24 Correct 78 ms 13000 KB Output is correct
25 Correct 86 ms 13132 KB Output is correct
26 Correct 68 ms 13012 KB Output is correct
27 Correct 869 ms 68092 KB Output is correct
28 Incorrect 894 ms 68160 KB Tree @(863, 999) appears more than once: for edges on positions 500 and 503
29 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 289 ms 40832 KB Output is correct
10 Correct 19 ms 3924 KB Output is correct
11 Correct 110 ms 21284 KB Output is correct
12 Correct 32 ms 6060 KB Output is correct
13 Correct 29 ms 7204 KB Output is correct
14 Correct 1 ms 340 KB Output is correct
15 Correct 1 ms 468 KB Output is correct
16 Correct 274 ms 40876 KB Output is correct
17 Correct 947 ms 123536 KB Output is correct
18 Correct 1078 ms 123660 KB Output is correct
19 Correct 1125 ms 161484 KB Output is correct
20 Correct 621 ms 53576 KB Output is correct
21 Correct 843 ms 64268 KB Output is correct
22 Correct 0 ms 212 KB Output is correct
23 Incorrect 93 ms 11908 KB Tree @(186073, 21295) appears more than once: for edges on positions 46 and 60
24 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 289 ms 40832 KB Output is correct
10 Correct 19 ms 3924 KB Output is correct
11 Correct 110 ms 21284 KB Output is correct
12 Correct 32 ms 6060 KB Output is correct
13 Correct 29 ms 7204 KB Output is correct
14 Correct 1 ms 340 KB Output is correct
15 Correct 1 ms 468 KB Output is correct
16 Correct 274 ms 40876 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 0 ms 212 KB Output is correct
19 Correct 0 ms 212 KB Output is correct
20 Correct 1 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 706 ms 72676 KB Output is correct
24 Correct 1 ms 212 KB Output is correct
25 Correct 3 ms 724 KB Output is correct
26 Correct 2 ms 596 KB Output is correct
27 Correct 2 ms 596 KB Output is correct
28 Correct 250 ms 26508 KB Output is correct
29 Correct 395 ms 48168 KB Output is correct
30 Correct 506 ms 61692 KB Output is correct
31 Correct 654 ms 72876 KB Output is correct
32 Correct 0 ms 212 KB Output is correct
33 Correct 0 ms 212 KB Output is correct
34 Correct 0 ms 212 KB Output is correct
35 Correct 0 ms 212 KB Output is correct
36 Correct 0 ms 212 KB Output is correct
37 Correct 0 ms 212 KB Output is correct
38 Correct 1 ms 212 KB Output is correct
39 Correct 0 ms 212 KB Output is correct
40 Correct 0 ms 212 KB Output is correct
41 Correct 0 ms 212 KB Output is correct
42 Correct 1 ms 212 KB Output is correct
43 Correct 1 ms 468 KB Output is correct
44 Correct 2 ms 468 KB Output is correct
45 Correct 433 ms 36388 KB Output is correct
46 Correct 599 ms 53124 KB Output is correct
47 Correct 588 ms 53380 KB Output is correct
48 Correct 0 ms 212 KB Output is correct
49 Correct 0 ms 212 KB Output is correct
50 Correct 0 ms 212 KB Output is correct
51 Incorrect 0 ms 212 KB Tree @(5, 5) appears more than once: for edges on positions 1 and 4
52 Halted 0 ms 0 KB -