oj.uz

답안 #940631

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
940631 2024-03-07T12:12:16 Z vjudge1 미술 수업 (IOI13_artclass) C++17
54 / 100
 72 ms 28144 KB 
#include <bits/stdc++.h>
using namespace std;

#define f first
#define s second
#define pii pair<int, int>
#define all(v) v.begin(), v.end()
#define ll long long
#define pb push_back

#include "artclass.h"

vector<int> dx = {0, 0, 1, -1};
vector<int> dy = {-1, 1, 0, 0};

vector<vector<int>> was, r, g, b;
int n, m;

bool good(int x, int y)
{
    return x >= 0 and y >= 0 and x < n and y < m;
}

int dfs1(int x, int y)
{
    assert(x < n);
    assert(y < m);
    assert(!was[x][y]);
    assert(x >= 0);
    assert(y >= 0);
    was[x][y] = 1;
    int sz = 1;
    for (int d = 0; d < 4; ++d)
    {
        int tox = x + dx[d];
        int toy = y + dy[d];
        if (good(tox, toy) and !was[tox][toy])
        {
            assert(tox < n and toy < m);
            int diff = abs(r[x][y] - r[tox][toy]) + abs(g[x][y] - g[tox][toy]) + abs(b[x][y] - b[tox][toy]);
            if (diff <= 40)
                sz += dfs1(tox, toy);
        }
    }
    return sz;
}

int dfs2(int x, int y)
{
    was[x][y] = 1;
    int sz = 1;
    for (int d = 0; d < 4; ++d)
    {
        int tox = x + dx[d];
        int toy = y + dy[d];
        if (good(tox, toy) and !was[tox][toy])
        {
            int diff = abs(r[x][y] - r[tox][toy]) + abs(g[x][y] - g[tox][toy]) + abs(b[x][y] - b[tox][toy]);
            if (diff <= 14)
                sz += dfs2(tox, toy);
        }
    }
    return sz;
}

int style(int H, int W, int R[500][500], int G[500][500], int B[500][500])
{
    was.resize(H + 100, vector<int>(W + 100));
    r.resize(H + 100, vector<int>(W + 100));
    g.resize(H + 100, vector<int>(W + 100));
    b.resize(H + 100, vector<int>(W + 100));
    n = H;
    m = W;

    vector<int> d;

    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
        {
            r[i][j] = R[i][j];
            g[i][j] = G[i][j];
            b[i][j] = B[i][j];
        }
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            if (!was[i][j])
                d.pb(dfs1(i, j));

    sort(all(d));
    reverse(all(d));
    if ((int)d.size() == 1)
        return 4;
    if (d[0] + d[1] >= (double)(n * m) * 0.70)
        return 4;
    // cout << d[0] << " " << d[1] << ": " << (double)(n * m) * 0.60 << "!\n";
    d.clear();
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            was[i][j] = 0;

    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            if (!was[i][j])
                d.pb(dfs2(i, j));

    if (((double)d.size() / (double)(H * W)) <= 0.1)
        return 1;
    if (((double)d.size() / (double)(H * W)) >= 0.7)
        return 3;
    return 2;
}

// #include <stdio.h>
// #include "artclass.h"
// #include <assert.h>

// static int DIM[2];
// static int R[500][500];
// static int G[500][500];
// static int B[500][500];

// int main()
// {
//     assert(scanf("%d", &DIM[1]) == 1);
//     assert(scanf("%d", &DIM[0]) == 1);
//     for (int i = 0; i < DIM[0]; i++)
//         for (int j = 0; j < DIM[1]; j++)
//             assert(scanf("%d %d %d", &R[i][j], &G[i][j], &B[i][j]) == 3);
//     printf("%d\n", style(DIM[0], DIM[1], R, G, B));
//     return 0;
// }

Subtask #1
54.0 / 100.0

# 결과 실행 시간 메모리 Grader output
1 Correct 31 ms 6960 KB Output is correct
2 Correct 42 ms 12088 KB Output is correct
3 Correct 34 ms 7260 KB Output is correct
4 Incorrect 28 ms 7764 KB Output isn't correct
5 Correct 54 ms 9424 KB Output is correct
6 Incorrect 60 ms 9824 KB Output isn't correct
7 Correct 34 ms 11828 KB Output is correct
8 Correct 41 ms 7900 KB Output is correct
9 Incorrect 63 ms 10316 KB Output isn't correct
10 Incorrect 56 ms 10320 KB Output isn't correct
11 Correct 44 ms 8652 KB Output is correct
12 Correct 26 ms 6120 KB Output is correct
13 Correct 54 ms 12736 KB Output is correct
14 Incorrect 47 ms 10068 KB Output isn't correct
15 Incorrect 37 ms 9820 KB Output isn't correct
16 Correct 31 ms 13140 KB Output is correct
17 Correct 53 ms 10068 KB Output is correct
18 Correct 72 ms 12628 KB Output is correct
19 Correct 37 ms 7420 KB Output is correct
20 Incorrect 28 ms 9116 KB Output isn't correct
21 Correct 51 ms 22548 KB Output is correct
22 Correct 31 ms 6872 KB Output is correct
23 Correct 48 ms 9936 KB Output is correct
24 Incorrect 46 ms 11604 KB Output isn't correct
25 Incorrect 39 ms 7676 KB Output isn't correct
26 Incorrect 49 ms 9160 KB Output isn't correct
27 Correct 50 ms 11348 KB Output is correct
28 Correct 63 ms 28144 KB Output is correct
29 Correct 44 ms 18768 KB Output is correct
30 Correct 37 ms 7632 KB Output is correct
31 Correct 47 ms 8660 KB Output is correct
32 Incorrect 45 ms 11856 KB Output isn't correct
33 Incorrect 41 ms 12124 KB Output isn't correct
34 Correct 54 ms 11724 KB Output is correct
35 Correct 43 ms 16976 KB Output is correct
36 Correct 49 ms 8660 KB Output is correct
37 Correct 52 ms 12116 KB Output is correct
38 Correct 46 ms 21840 KB Output is correct
39 Correct 32 ms 12524 KB Output is correct
40 Incorrect 63 ms 12068 KB Output isn't correct
41 Incorrect 57 ms 9180 KB Output isn't correct
42 Correct 48 ms 9012 KB Output is correct
43 Correct 50 ms 22868 KB Output is correct
44 Incorrect 41 ms 12368 KB Output isn't correct
45 Correct 13 ms 7260 KB Output is correct
46 Incorrect 46 ms 8144 KB Output isn't correct
47 Incorrect 41 ms 10832 KB Output isn't correct
48 Incorrect 40 ms 11100 KB Output isn't correct
49 Correct 57 ms 13660 KB Output is correct
50 Correct 44 ms 11992 KB Output is correct
51 Correct 47 ms 17596 KB Output is correct
52 Correct 39 ms 10584 KB Output is correct
53 Correct 19 ms 4972 KB Output is correct
54 Correct 32 ms 6940 KB Output is correct
55 Correct 44 ms 17244 KB Output is correct
56 Correct 35 ms 9052 KB Output is correct
57 Correct 46 ms 22100 KB Output is correct
58 Correct 41 ms 12372 KB Output is correct
59 Correct 35 ms 15952 KB Output is correct
60 Correct 48 ms 9132 KB Output is correct
61 Incorrect 44 ms 9892 KB Output isn't correct
62 Correct 33 ms 12884 KB Output is correct
63 Incorrect 44 ms 8396 KB Output isn't correct
64 Incorrect 49 ms 8664 KB Output isn't correct
65 Incorrect 52 ms 9416 KB Output isn't correct
66 Correct 57 ms 13136 KB Output is correct
67 Correct 66 ms 9776 KB Output is correct
68 Correct 49 ms 9668 KB Output is correct
69 Correct 51 ms 9668 KB Output is correct
70 Incorrect 42 ms 11596 KB Output isn't correct
71 Correct 39 ms 7508 KB Output is correct
72 Incorrect 69 ms 10136 KB Output isn't correct
73 Correct 38 ms 7892 KB Output is correct
74 Correct 37 ms 18796 KB Output is correct
75 Incorrect 53 ms 9312 KB Output isn't correct
76 Correct 49 ms 21584 KB Output is correct
77 Correct 50 ms 9932 KB Output is correct
78 Correct 52 ms 11600 KB Output is correct
79 Incorrect 46 ms 12880 KB Output isn't correct
80 Correct 57 ms 12900 KB Output is correct
81 Correct 48 ms 9168 KB Output is correct
82 Correct 35 ms 14724 KB Output is correct
83 Incorrect 43 ms 13624 KB Output isn't correct
84 Incorrect 44 ms 13136 KB Output isn't correct
85 Correct 42 ms 8656 KB Output is correct
86 Incorrect 38 ms 9808 KB Output isn't correct
87 Correct 48 ms 9160 KB Output is correct
88 Incorrect 39 ms 10320 KB Output isn't correct
89 Correct 49 ms 11380 KB Output is correct
90 Correct 61 ms 12624 KB Output is correct
91 Correct 44 ms 15768 KB Output is correct
92 Correct 51 ms 9660 KB Output is correct
93 Correct 27 ms 6360 KB Output is correct
94 Correct 30 ms 6620 KB Output is correct
95 Incorrect 57 ms 8184 KB Output isn't correct
96 Correct 54 ms 24404 KB Output is correct
97 Correct 50 ms 10188 KB Output is correct
98 Correct 48 ms 10576 KB Output is correct
99 Correct 44 ms 20944 KB Output is correct
100 Correct 52 ms 23380 KB Output is correct
101 Correct 51 ms 10184 KB Output is correct
102 Correct 52 ms 23860 KB Output is correct