CSES - Aalto Competitive Programming 2024 - wk10 - Mon - Results
Submission details
Task:Modern art
Sender:Farah
Submission time:2024-11-11 17:48:34 +0200
Language:C++ (C++20)
Status:READY
Result:
Test results
testverdicttime
#1ACCEPTED0.00 sdetails
#20.00 sdetails
#3ACCEPTED0.00 sdetails
#4ACCEPTED0.00 sdetails
#5ACCEPTED0.00 sdetails
#6ACCEPTED0.00 sdetails
#7ACCEPTED0.00 sdetails
#8ACCEPTED0.00 sdetails
#9ACCEPTED0.00 sdetails
#100.00 sdetails
#11ACCEPTED0.00 sdetails
#120.00 sdetails
#13ACCEPTED0.00 sdetails
#14ACCEPTED0.00 sdetails
#15ACCEPTED0.00 sdetails
#16ACCEPTED0.00 sdetails
#17ACCEPTED0.00 sdetails
#18ACCEPTED0.00 sdetails
#19ACCEPTED0.00 sdetails
#200.00 sdetails
#21ACCEPTED0.00 sdetails
#220.00 sdetails
#230.00 sdetails
#24ACCEPTED0.00 sdetails
#25ACCEPTED0.00 sdetails
#260.00 sdetails
#27ACCEPTED0.00 sdetails
#280.00 sdetails
#29ACCEPTED0.00 sdetails
#300.00 sdetails
#31ACCEPTED0.00 sdetails
#320.00 sdetails
#330.00 sdetails
#34ACCEPTED0.00 sdetails
#35ACCEPTED0.00 sdetails
#360.00 sdetails
#37ACCEPTED0.00 sdetails
#380.00 sdetails
#39ACCEPTED0.00 sdetails
#400.00 sdetails
#41ACCEPTED0.00 sdetails
#420.00 sdetails
#430.00 sdetails
#440.00 sdetails
#45ACCEPTED0.00 sdetails
#460.00 sdetails
#47ACCEPTED0.00 sdetails
#480.00 sdetails
#49ACCEPTED0.00 sdetails
#500.00 sdetails

Compiler report

input/code.cpp: In function 'int main()':
input/code.cpp:19:17: warning: unused variable 'max_P' [-Wunused-variable]
   19 |             int max_P = min_P + 2*needed_protrusions;
      |                 ^~~~~

Code

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int A, P;
    cin >> A >> P;
    bool possible = false;
    int final_w, final_h, protrusions;
    for(int w=1; w<=A && !possible; w++){
        for(int h=1; h<=A/w && !possible; h++){
            if(w*h > A) continue;
            int min_P = 2*(w + h);
            int needed_protrusions = A - w*h;
            int max_P = min_P + 2*needed_protrusions;
            if(P == min_P + 2*needed_protrusions){
                final_w = w;
                final_h = h;
                protrusions = needed_protrusions;
                possible = true;
            }
        }
    }
    if(!possible){
        cout << "IMPOSSIBLE";
        return 0;
    }
    int grid_rows = final_h + 2;
    int grid_cols = final_w + 2;
    vector<vector<char>> grid(grid_rows, vector<char>(grid_cols, '0'));
    for(int i=1; i<=final_h; i++) {
        for(int j=1; j<=final_w; j++) {
            grid[i][j] = '1';
        }
    }
    int added = 0;
    for(int i=1; i<=final_h && added < protrusions; i++){
        for(int j=1; j<=final_w && added < protrusions; j++){
            if(added >= protrusions) break;
            // Try to add protrusions to the top
            if(i >1 && grid[i-1][j] == '0'){
                grid[i-1][j] = '1';
                added++;
                continue;
            }
            // Try to add protrusions to the bottom
            if(i < final_h && grid[i+1][j] == '0'){
                grid[i+1][j] = '1';
                added++;
                continue;
            }
            // Try to add protrusions to the left
            if(j >1 && grid[i][j-1] == '0'){
                grid[i][j-1] = '1';
                added++;
                continue;
            }
            // Try to add protrusions to the right
            if(j < final_w && grid[i][j+1] == '0'){
                grid[i][j+1] = '1';
                added++;
                continue;
            }
        }
    }
    if(added != protrusions){
        cout << "IMPOSSIBLE";
        return 0;
    }
    // Calculate perimeter
    int calc_P =0;
    vector<pair<int, int>> dirs = { {-1,0}, {1,0}, {0,-1}, {0,1} };
    for(int i=1; i<grid_rows-1; i++){
        for(int j=1; j<grid_cols-1; j++){
            if(grid[i][j] == '1'){
                for(auto &[dx, dy] : dirs){
                    int ni = i + dx;
                    int nj = j + dy;
                    if(grid[ni][nj] == '0') calc_P++;
                }
            }
        }
    }
    if(calc_P != P){
        cout << "IMPOSSIBLE";
        return 0;
    }
    cout << "POSSIBLE\n";
    for(auto &row : grid){
        for(auto &c : row) cout << c;
        cout << '\n';
    }
}

Test details

Test 1

Verdict: ACCEPTED

input
5 14

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 2

Verdict:

input
6 14

correct output
POSSIBLE
000
010
010
010
...

user output
IMPOSSIBLE

Test 3

Verdict: ACCEPTED

input
7 10

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 4

Verdict: ACCEPTED

input
5 5

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 5

Verdict: ACCEPTED

input
6 22

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 6

Verdict: ACCEPTED

input
7 10

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 7

Verdict: ACCEPTED

input
5 20

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 8

Verdict: ACCEPTED

input
6 8

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 9

Verdict: ACCEPTED

input
7 4

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 10

Verdict:

input
5 10

correct output
POSSIBLE
0000
0110
0110
0100
...

user output
IMPOSSIBLE

Test 11

Verdict: ACCEPTED

input
10 25

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 12

Verdict:

input
10 22

correct output
POSSIBLE
000
010
010
010
...

user output
IMPOSSIBLE

Test 13

Verdict: ACCEPTED

input
10 14

correct output
POSSIBLE
0000
0110
0110
0110
...

user output
POSSIBLE
0000
0110
0110
0110
...

Test 14

Verdict: ACCEPTED

input
10 6

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 15

Verdict: ACCEPTED

input
10 37

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 16

Verdict: ACCEPTED

input
10 12

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 17

Verdict: ACCEPTED

input
10 39

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 18

Verdict: ACCEPTED

input
10 14

correct output
POSSIBLE
0000
0110
0110
0110
...

user output
POSSIBLE
0000
0110
0110
0110
...

Test 19

Verdict: ACCEPTED

input
10 4

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 20

Verdict:

input
10 16

correct output
POSSIBLE
00000000
01111110
01111000
00000000

user output
IMPOSSIBLE

Test 21

Verdict: ACCEPTED

input
100 239

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 22

Verdict:

input
100 202

correct output
POSSIBLE
000
010
010
010
...

user output
IMPOSSIBLE

Test 23

Verdict:

input
100 70

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 24

Verdict: ACCEPTED

input
100 32

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 25

Verdict: ACCEPTED

input
100 361

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 26

Verdict:

input
100 48

correct output
POSSIBLE
00000000000000000000
01111111111111111110
01111111111111111110
01111111111111111110
...

user output
IMPOSSIBLE

Test 27

Verdict: ACCEPTED

input
100 380

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 28

Verdict:

input
100 76

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 29

Verdict: ACCEPTED

input
100 8

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 30

Verdict:

input
100 98

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 31

Verdict: ACCEPTED

input
200 476

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 32

Verdict:

input
200 402

correct output
POSSIBLE
000
010
010
010
...

user output
IMPOSSIBLE

Test 33

Verdict:

input
200 120

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 34

Verdict: ACCEPTED

input
200 60

correct output
POSSIBLE
000000000000
011111111110
011111111110
011111111110
...

user output
POSSIBLE
000000000000
011111111110
011111111110
011111111110
...

Test 35

Verdict: ACCEPTED

input
200 721

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 36

Verdict:

input
200 74

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 37

Verdict: ACCEPTED

input
200 759

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 38

Verdict:

input
200 134

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 39

Verdict: ACCEPTED

input
200 12

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 40

Verdict:

input
200 182

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 41

Verdict: ACCEPTED

input
1000 2373

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 42

Verdict:

input
1000 1998

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 43

Verdict:

input
1000 472

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 44

Verdict:

input
1000 286

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 45

Verdict: ACCEPTED

input
1000 3603

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 46

Verdict:

input
1000 228

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 47

Verdict: ACCEPTED

input
1000 3791

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 48

Verdict:

input
1000 552

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE

Test 49

Verdict: ACCEPTED

input
1000 48

correct output
IMPOSSIBLE

user output
IMPOSSIBLE

Test 50

Verdict:

input
1000 810

correct output
POSSIBLE
000000000000000000000000000000...

user output
IMPOSSIBLE