Maalaus

input/code.cpp: In function 'void draw_line(int, size_t, int)':
input/code.cpp:49:39: warning: comparison of integer expressions of different signedness: 'size_t' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
   49 |     for (size_t i = ops.size() - 1; i != -1; i--) {
      |                                     ~~^~~~~
input/code.cpp: In function 'int main()':
input/code.cpp:148:18: warning: format '%u' expects argument of type 'unsigned int', but argument 2 has type 'uint64_t' {aka 'long unsigned int'} [-Wformat=]
  148 |         printf("%u ", colors[i]);
      |                 ~^    ~~~~~~~~~
      |                  |            |
      |                  unsigned int uint64_t {aka long unsigned int}
      |                 %lu

#include <cstdlib>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>

uint64_t *colors;

size_t width;
size_t height;
size_t color_count;

struct Drawing {
    int rc;
    size_t n;
    int color;
};

struct Point {
    size_t x;
    size_t y;
};

std::vector<Drawing> ops;

Point intersection(int rc1, size_t n1, int rc2, size_t n2) {
    if (rc1 == 'C') {
        return { .x = n1,  .y = n2};
    } else {
        return { .x = n2,  .y = n1};
    }
}

void draw_line(int rc, size_t n, int color) {
    colors[color] += rc == 'R' ? width : height;

    if (ops.size() == 0) {
        ops.push_back({rc, n, color});
        return;
    }

    bool same_line = false;

    std::unordered_map<size_t, Point> intersections;
    for (size_t i = ops.size() - 1; i != -1; i--) {
        if (ops[i].rc != rc) {
            Point is = intersection(rc, n, ops[i].rc, ops[i].n);
            if (intersections.count(is.x + width * is.y) == 0) {
                colors[ops[i].color]--;
                intersections.insert({is.x + width * is.y, is});
            }
        } else {
            if (n != ops[i].n) {
                continue;
            }

            if (same_line) {
                continue;
            }

            std::unordered_set<size_t> is2;
            size_t covered = rc == 'R' ? width : height;
            for (size_t j = i + 1; j < ops.size(); j++) {
                if (ops[j].rc != ops[i].rc) {
                    Point is = intersection(ops[i].rc, ops[i].n, ops[j].rc, ops[j].n);
                    if (is2.count(is.x + width * is.y) == 0) {
                        covered--;
                        is2.insert(is.x + width * is.y);
                    }
                } else {
                    if (ops[i].n != ops[j].n) {
                        continue;
                    }

                    covered = 0;
                    break;
                }
            }

            colors[ops[i].color] -= covered;
            same_line = true;
        }
    }

    ops.push_back({rc, n, color});
}

int main(void) {
    char *input = (char *)malloc(1024*1024*8);
    const size_t len = read(0, input, 1024*1024*8);
    size_t idx = 0;

    size_t next_space = strchr(input, ' ') - input;
    input[next_space] = '\0';

    height = atoi(input);
    idx += next_space + 1;

    next_space = strchr((input + idx), ' ') - (input + idx);
    (input + idx)[next_space] = '\0';
    width = atoi((input + idx));
    idx += next_space + 1;

    next_space = strchr((input + idx), ' ') - (input + idx);
    (input + idx)[next_space] = '\0';
    color_count = atoi((input + idx));
    idx += next_space + 1;

    next_space = strchr((input + idx), '\n') - (input + idx);
    (input + idx)[next_space] = '\0';
    size_t operations = atoi((input + idx));
    idx += next_space + 1;

    colors = (uint64_t *)malloc((color_count + 1) * sizeof(uint64_t));
    ops.reserve(operations);

    for (size_t i = 0; i < color_count + 1; i++) {
        colors[i] = 0;
    }

    for (size_t i = 0; i < operations; i++) {
        int rc = (input + idx)[0];
        idx += 2;

        next_space = strchr((input + idx), ' ') - (input + idx);
        (input + idx)[next_space] = '\0';
        size_t n = atoi((input + idx));
        idx += next_space + 1;

        if (i == operations - 1) {
            next_space = len - ((input + idx) - input) - 1;
        } else {
            next_space = strchr((input + idx), '\n') - (input + idx);
        }

        (input + idx)[next_space] = '\0';
        size_t color = atoi((input + idx));
        idx += next_space + 1;

        draw_line(rc, n, color);
    }

    for (size_t i = 1; i < color_count + 1; i++) {
        printf("%u ", colors[i]);
    }

    free(input);
    free(colors);

}

Test 1 (public)

Group: 1, 3, 4

Verdict: ACCEPTED

Test 2 (public)

Group: 3, 4

Verdict: ACCEPTED

Test 3

Group: 1, 3, 4

Verdict: WRONG ANSWER

Test 4

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 5

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 6

Group: 3, 4

Verdict: WRONG ANSWER

Test 7

Group: 3, 4

Verdict: WRONG ANSWER

Test 8

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 1, 3, 4

Verdict: WRONG ANSWER

Test 11

Group: 1, 3, 4

Verdict: WRONG ANSWER

Test 12

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 4

Verdict: TIME LIMIT EXCEEDED