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;
    }

    // Exceptions:
    // - no operations are defined
    // - only rows are given
    // - only cols are given
    // Ignore if exception moment
    if (next_col_index && next_row_index) {
        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