Maalaus

input/code.cpp: In function 'int main()':
input/code.cpp:112:23: warning: comparison of integer expressions of different signedness: 'int' and 'uint' {aka 'unsigned int'} [-Wsign-compare]
  112 |     for (int i = 0; i < color_count; i++) {
      |                     ~~^~~~~~~~~~~~~
input/code.cpp:156:23: warning: comparison of integer expressions of different signedness: 'uint' {aka 'unsigned int'} and 'int' [-Wsign-compare]
  156 |             if (ctime > row.time) { ctime--; cur_rowtype = RowType::COL; continue; }
      |                 ~~~~~~^~~~~~~~~~
input/code.cpp:165:23: warning: comparison of integer expressions of different signedness: 'uint' {aka 'unsigned int'} and 'int' [-Wsign-compare]
  165 |             if (ctime > col.time) { ctime--; cur_rowtype = RowType::ROW; continue; }
      |                 ~~~~~~^~~~~~~~~~
input/code.cpp:108:10: warning: unused variable 'affected_rows' [-Wunused-variable]
  108 |     uint affected_rows = wid - unaffected_rows;
      |...

#include <iostream>
#include <vector>
//#include <unordered_map>
#include <set>

#define to_rowtype(row) (row == 'R' ? RowType::ROW : RowType::COL)
#define to_char(row) (row == RowType::ROW ? 'R' : 'C')

enum RowType {
    ROW,
    COL
};

typedef unsigned int uint;

typedef struct Operation {
    int idx;
    int time;
    int color;
} Operation;


void print_op(std::vector<Operation> arr) {
    for (Operation cur : arr) {
        std::cout << cur.idx << ' ' << cur.time << ' ' << cur.color << std::endl;
    }
}

void print_colors(uint* colors, int size) {
    for (int i = 0; i < size; i++) {
        std::cout << colors[i] << ' ';
    }
    std::cout << std::endl;
}

uint hgt, wid, color_count, operation_count;

int main() {
    int time = 0;
    std::vector<Operation> row_operations;
    std::vector<Operation> col_operations;
    /*row_operations.push_back({ -1, -1, -1 });
    col_operations.push_back({ -1, -1, -1 });*/

    uint next_row_index = 0;
    uint next_col_index = 0;
    std::set<uint> existing_rows;
    std::set<uint> existing_cols;
    //std::unordered_map<uint, uint> row_translation;
    //std::unordered_map<uint, uint> col_translation;

    std::cin >> hgt >> wid >> color_count >> operation_count;
 
    char rows[20000];
    uint indices[20000];
    uint colors[20000];
    for (uint i = 0; i < operation_count; i++) {
        std::cin >> rows[i] >> indices[i] >> colors[i];
        colors[i]--;
    }

    char last_row;
    for (uint i = operation_count - 1; i > 0; i--) {
        char row = rows[i];
        int idx = indices[i];
        int color = colors[i];

        if (row != last_row) { time++; }

        RowType row_type = to_rowtype(row);
        if (row_type == RowType::ROW) {
            //uint translated_row;
            if (existing_rows.count(idx) == 0) {
                existing_rows.insert(idx);
                int translated_row = next_row_index++;
                row_operations.push_back({
                    translated_row, time, color
                });
            } /*else { // Ignore older write to row, a more recent one exists
                translated_row = row_translation[idx];
                row_operations[translated_row] = {
                    row_type, time, color
                };
            }*/ 
        } else {
            //uint translated_col;
            if (existing_cols.count(idx) == 0) {
                existing_cols.insert(idx);
                int translated_col = next_col_index++;
                col_operations.push_back({
                    translated_col, time, color
                });
            } /* else { // Ignore older write to row, a more recent one exists
                translated_col = col_translation[idx];
                col_operations[translated_col] = {
                    row_type, time, color
                };
            }*/
            
        }

        last_row = row;
    }

    uint unaffected_rows = wid - next_col_index;
    uint unaffected_cols = hgt - next_row_index;

    uint affected_rows = wid - unaffected_rows;
    uint affected_cols = hgt - unaffected_cols;

    uint colors_sum[20000];
    for (int i = 0; i < color_count; i++) {
        colors_sum[i] = 0;
    }

    /*std::cout << std::endl;
    std::cout << "wid: " << wid << ", hgt: " << hgt << std::endl;
    std::cout << std::endl;
    std::cout << "rows: " << unaffected_rows << ", cols: " << unaffected_cols << std::endl;
    std::cout << std::endl;
    print_op(row_operations); */
    // calc unaffected row/cols, add to sum
    for (Operation operation : row_operations) {
        colors_sum[operation.color] += unaffected_rows;
    }
    /*print_colors(colors_sum, color_count);
    std::cout << std::endl;

    print_op(col_operations); */
    for (Operation operation : col_operations) {
        colors_sum[operation.color] += unaffected_cols;
    }

    //print_colors(colors_sum, color_count);
    //std::cout << std::endl;
    
    // calc collision area by iterating unaffected rows and cols backwards, and switching when the Time changes 
    int row_index = row_operations.size() - 1;
    int col_index = col_operations.size() - 1;
    RowType cur_rowtype;
    uint ctime;
    if (row_operations[row_index].time < col_operations[col_index].time) {
        ctime = row_operations[row_index].time;
        cur_rowtype = RowType::ROW;
    } else {
        ctime = col_operations[col_index].time;
        cur_rowtype = RowType::COL;
    }

    while (row_index >= 0 && col_index >= 0) {
        //std::cout << "row: " << row_index << ", col: " << col_index << std::endl;
        if (cur_rowtype == RowType::ROW) {
            //std::cout << "ROW " << row_index << std::endl;
            Operation row = row_operations[row_index];

            if (ctime > row.time) { ctime--; cur_rowtype = RowType::COL; continue; }

            colors_sum[row.color] += col_index + 1;
            
            row_index--;
        } else {
            //std::cout << "COL " << col_index << std::endl;
            Operation col = col_operations[col_index];
            
            if (ctime > col.time) { ctime--; cur_rowtype = RowType::ROW; continue; }

            colors_sum[col.color] += row_index + 1;
            
            col_index--;
        }
    }

    //colors_sum[row_operations[0].color] += row_operations.size() - row_index;
    //colors_sum[col_operations[0].color] += col_operations.size() - col_index;

    // print
    for (uint i = 0; i < color_count; i++) {
        std::cout << colors_sum[i] << ' ';
    }
    std::cout.flush();

    return 0;
}

Test 1 (public)

Group: 1, 3, 4

Verdict: ACCEPTED

Test 2 (public)

Group: 3, 4

Verdict: WRONG ANSWER

Test 3

Group: 1, 3, 4

Verdict: WRONG ANSWER

Test 4

Group: 2, 4

Verdict: RUNTIME ERROR

Test 5

Group: 2, 4

Verdict: RUNTIME ERROR

Test 6

Group: 3, 4

Verdict: WRONG ANSWER

Test 7

Group: 3, 4

Verdict: WRONG ANSWER

Test 8

Group: 4

Verdict: RUNTIME ERROR

Test 9

Group: 4

Verdict: RUNTIME ERROR

Test 10

Group: 1, 3, 4

Verdict: WRONG ANSWER

Test 11

Group: 1, 3, 4

Verdict: ACCEPTED

Test 12

Group: 2, 4

Verdict: RUNTIME ERROR

Test 13

Group: 2, 4

Verdict: RUNTIME ERROR

Test 14

Group: 4

Verdict: RUNTIME ERROR

Test 15

Group: 4

Verdict: RUNTIME ERROR

Test 16

Group: 4

Verdict: RUNTIME ERROR

Test 17

Group: 4

Verdict: RUNTIME ERROR