Maalaus

input/code.cpp: In function 'void print_op(std::vector<Operation>)':
input/code.cpp:24:20: warning: variable 'cur' set but not used [-Wunused-but-set-variable]
   24 |     for (Operation cur : arr) {
      |                    ^~~

#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];
    /*std::cout << "before: " << std::endl;
    print_colors(colors, operation_count);*/
    for (uint i = 0; i < operation_count; i++) {
        std::cin >> rows[i] >> indices[i] >> colors[i];
        colors[i]--;
    }
    /*std::cout << "after: " << std::endl;
    print_colors(colors, operation_count);
    std::cout << std::endl;*/

    char last_row = 'Z';
    for (int i = operation_count - 1; i >= 0; i--) {
        char row = rows[i];
        int idx = indices[i];
        int color = colors[i];
        //std::cout << "row: " << row << ", idx: " << idx << ", color: " << color << std::endl;

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

        RowType row_type = to_rowtype(row);
        if (row_type == RowType::ROW) {
            if (existing_rows.count(idx) == 0) {
                existing_rows.insert(idx);
                int translated_row = next_row_index++;
                //std::cout << "next_row_index: " << next_row_index << std::endl;
                row_operations.push_back({
                    translated_row, time, color
                });
            }

        } else {
            if (existing_cols.count(idx) == 0) {
                existing_cols.insert(idx);
                int translated_col = next_col_index++;
                //std::cout << "next_col_index: " << next_col_index << std::endl;
                col_operations.push_back({
                    translated_col, time, color
                });
            }
        }

        last_row = row;
    }

    //print_op(row_operations);
    //print_op(col_operations);

    int rows_left_unmodified = hgt - next_row_index;
    //std::cout << "hgt: " << hgt << ", next_row_index: " << next_row_index << ", rows left unmodified: " << rows_left_unmodified << std::endl;
    int cols_left_unmodified = wid - next_col_index;
    //std::cout << "wid: " << wid << ", next_col_index: " << next_col_index << ", cols left unmodified: " << cols_left_unmodified << std::endl;

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

    for (Operation operation: row_operations) {
        colors_sum[operation.color] += cols_left_unmodified;
    }

    for (Operation operation: col_operations) {
        colors_sum[operation.color] += rows_left_unmodified;
    }

    time = 0;
    RowType cur_type;
    int row_index = 0;
    int row_length = next_row_index - 1;
    int col_index = 0;
    int col_length = next_col_index - 1;

    if (row_operations[0].time < col_operations[0].time) {
        time = row_operations[row_index].time;
        cur_type = RowType::ROW;
    } else {
        time = col_operations[col_index].time;
        cur_type = RowType::COL;
    }

    while (row_length >= 0 && col_length >= 0) {
        if (cur_type == RowType::ROW) {
            Operation row = row_operations[row_index];
            //std::cout << "ROW " << row_index << ", color: " << row.color << ", time: " << time << ", rowtime: " << row.time << std::endl;
            
            if (time < row.time) { time++; cur_type = RowType::COL; continue; }

            //std::cout << "Add " << col_length + 1 << " to " << row.color << std::endl;
            colors_sum[row.color] += col_length + 1;
            
            row_index++;
            row_length--;
        } else {
            Operation col = col_operations[col_index];
            //std::cout << "COL " << col_index << ", color: " << col.color << ", time: " << time << ", rowtime: " << col.time << std::endl;
            
            if (time < col.time) { time++; cur_type = RowType::ROW; continue; }

            //std::cout << "Add " << row_length + 1 << " to " << col.color << std::endl;
            colors_sum[col.color] += row_length + 1;
            
            col_index++;
            col_length--;
        }
    }
    

    // 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: ACCEPTED

Test 3

Group: 1, 3, 4

Verdict: ACCEPTED

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: ACCEPTED

Test 8

Group: 4

Verdict: RUNTIME ERROR

Test 9

Group: 4

Verdict: RUNTIME ERROR

Test 10

Group: 1, 3, 4

Verdict: ACCEPTED

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