Maalaus

input/code.cpp: In function 'int main()':
input/code.cpp:215:23: warning: comparison of integer expressions of different signedness: 'int' and 'size_t' {aka 'long unsigned int'} [-Wsign-compare]
  215 |     for (int i = 0; i < numOperations; ++i) {
      |                     ~~^~~~~~~~~~~~~~~

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <array>
#include <unordered_set>
#include <unordered_map>
#include <cstdint>

template <typename T>
class Grid2D {
public:
    Grid2D(size_t width, size_t height, const T& fill = T()) 
        : m_width(width), m_height(height) 
    { 
        std::cout << "s" << std::endl;
        m_data.resize(width * height, fill);
        std::cout << "e "<< std::endl;
    }
        
    const T& At(size_t x, size_t y) const { return m_data.at(GetIndex(x, y)); }

    T& At(size_t x, size_t y) { return m_data.at(GetIndex(x, y));  }

    size_t GetWidth() const { return m_width; }

    size_t  GetHeight() const { return m_height; }

private:

    size_t GetIndex(size_t x, size_t y) const { return y * m_width + x; }

    std::vector<T> m_data;
    size_t m_width = 0;
    size_t m_height = 0;
};

enum OperationType : uint8_t {
    Row = 0,
    Column
};

struct Operation {
    OperationType type = OperationType::Column;
    size_t position = 0;
    size_t color = 0;
};

struct Line {
    size_t position;
    size_t color;
    std::unordered_set<size_t> removals;
};

class Painting {
public:

    Painting(size_t width, size_t height, size_t numcolors)
        : m_width(width), m_height(height), m_numColors(numcolors) 
    {
        m_counts.resize(m_numColors);
    }

    void RunOperations(const std::vector<Operation>& operations) {
        for (int i = operations.size()-1; i >= 0; --i) {
            RunOperation(operations[i]);
        }
    }

    void RunOperation(const Operation& op) {
        if (op.type == OperationType::Row && m_rows.count(op.position) == 0) {
            size_t c = m_width - m_cols.size();
            m_counts[op.color - 1] += c;
            m_rows.insert(op.position);
        }

        else if (op.type == OperationType::Column && m_cols.count(op.position) == 0) {
            size_t c = m_height - m_rows.size();
            m_counts[op.color - 1] += c;
            m_cols.insert(op.position);
        }
    }

    std::vector<size_t> CountColors() {

        //std::cout << "numcolors: " << m_numColors << std::endl;
        /*std::vector<size_t> counts;
        counts.resize(m_numColors, 0);

        for (const auto& row : m_rows) {
            if (row.second.color == 0) continue;
            counts[row.second.color-1] += m_width - row.second.removals.size();
        }

        for (const auto& col : m_columns) {
            if (col.second.color == 0) continue;
            counts[col.second.color-1] += m_height - col.second.removals.size();
        }*/
/*
        for (int y = 0; y < m_data.GetHeight(); ++y) {
            for (int x = 0; x < m_data.GetWidth(); ++x) {
                size_t color = m_data.At(x,y);
                if (color == 0) continue;
                if (counts.size() <= color-1) {
                    counts.resize(color, 0);
                }
                counts.at(color-1)++;
            }
        }*/

        return m_counts;
    }

    /*void Print() {
        std::cout << "cols: " << m_columns.size() << " rows: " << m_rows.size() << std::endl;
        for (int y = 0; y < m_height; ++y) {
            for (int x = 0; x < m_width; ++x) {
                size_t color = 0;
                for (const auto& row : m_rows) {
                    if (row.second.position == y && row.second.removals.count(x) == 0) {
                        color = row.second.color;
                    }
                }
                for (const auto& col : m_columns) {
                    if (col.second.position == x && col.second.removals.count(y) == 0) {
                        color = col.second.color;
                    }
                }
                std::cout << (size_t)color << " ";
            }
            std::cout << std::endl;
        }
    }*/

private:

    /*std::unordered_map<size_t, Line> m_rows;
    std::unordered_map<size_t, Line> m_columns;*/

    std::unordered_set<size_t> m_rows;
    std::unordered_set<size_t> m_cols;

    std::vector<size_t> m_counts;

    size_t m_width;
    size_t m_height;

    size_t m_numColors;

};

void ReadParams(
    const std::string& str, 
    size_t* width, 
    size_t* height, 
    size_t* numColors, 
    size_t* numOperations)
{
    std::string token;
    std::stringstream ss(str);

    std::getline(ss, token, ' ');
    *height = std::stoi(token);

    std::getline(ss, token, ' ');
    *width = std::stoi(token);

    std::getline(ss, token, ' ');
    *numColors = std::stoi(token);

    std::getline(ss, token, ' ');
    *numOperations = std::stoi(token);
}

Operation ReadOperation(const std::string& str) {
    std::string token;
    std::stringstream ss(str);

    Operation op;

    std::getline(ss, token, ' ');
    if (token == "R") {
        op.type = OperationType::Row;
    } else if (token == "C") {
        op.type = OperationType::Column;
    } else {
        return Operation{};
    }

    std::getline(ss, token, ' ');
    op.position = std::stoi(token)-1;

    std::getline(ss, token, ' ');
    op.color = std::stoi(token);

    //std::cout << "Op: " << (size_t)op.type << ", " << op.position << ", " << op.color << std::endl;

    return op;
}

int main() {

    

    std::string params;
    std::getline(std::cin, params);

    size_t width, height, numColors, numOperations;

    ReadParams(params, &width, &height, &numColors, &numOperations);

    std::vector<Operation> operations;

    std::string line;
    for (int i = 0; i < numOperations; ++i) {
        std::getline(std::cin, line);
        operations.push_back(ReadOperation(line));
    }

    /*for (int i = 0; i < 100; ++i) {
        operations.push_back({(OperationType)(rand()%2),rand()%std::min(width, height),1+(rand()%numColors)});
    }*/

    //std::cout << std::endl;

    //std::cout << width << ", " << height << ", " << numColors << ", " << numOperations << std::endl;


    Painting p(width, height, numColors);

    p.RunOperations(operations);

    //p.Print();

    //p.Print();

    std::vector<size_t> counts = p.CountColors();

    for (auto c : counts) {
        std::cout << c << " ";
    }
    std::cout << std::endl;


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

Test 5

Group: 2, 4

Verdict: ACCEPTED

Test 6

Group: 3, 4

Verdict: ACCEPTED

Test 7

Group: 3, 4

Verdict: ACCEPTED

Test 8

Group: 4

Verdict: ACCEPTED

Test 9

Group: 4

Verdict: ACCEPTED

Test 10

Group: 1, 3, 4

Verdict: ACCEPTED

Test 11

Group: 1, 3, 4

Verdict: ACCEPTED

Test 12

Group: 2, 4

Verdict: ACCEPTED

Test 13

Group: 2, 4

Verdict: ACCEPTED

Test 14

Group: 4

Verdict: ACCEPTED

Test 15

Group: 4

Verdict: ACCEPTED

Test 16

Group: 4

Verdict: ACCEPTED

Test 17

Group: 4

Verdict: ACCEPTED