Maalaus

input/code.cpp: In member function 'void Painting::PaintRow(size_t, size_t)':
input/code.cpp:50:27: warning: comparison of integer expressions of different signedness: 'int' and 'size_t' {aka 'long unsigned int'} [-Wsign-compare]
   50 |         for (int x = 0; x < m_data.GetWidth(); ++x) {
      |                         ~~^~~~~~~~~~~~~~~~~~~
input/code.cpp: In member function 'void Painting::PaintColumn(size_t, size_t)':
input/code.cpp:56:27: warning: comparison of integer expressions of different signedness: 'int' and 'size_t' {aka 'long unsigned int'} [-Wsign-compare]
   56 |         for (int y = 0; y < m_data.GetHeight(); ++y) {
      |                         ~~^~~~~~~~~~~~~~~~~~~~
input/code.cpp: In member function 'void Painting::Print()':
input/code.cpp:62:27: warning: comparison of integer expressions of different signedness: 'int' and 'size_t' {aka 'long unsigned int'} [-Wsign-compare]
   62 |         for (int y = 0; y < m_data.GetHeight(); ++y) {
      |...

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <array>
#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) 
    { m_data.resize(width * height, fill); }
        
    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;
};

class Painting {
public:

    Painting(size_t width, size_t height)
        : m_data(width, height, 0) {}

    void PaintRow(size_t row, size_t color) {
        for (int x = 0; x < m_data.GetWidth(); ++x) {
            m_data.At(x, row) = color;
        }
    }

    void PaintColumn(size_t col, size_t color) {
        for (int y = 0; y < m_data.GetHeight(); ++y) {
            m_data.At(col, y) = color;
        }
    }
    
    void Print() {
        for (int y = 0; y < m_data.GetHeight(); ++y) {
            for (int x = 0; x < m_data.GetWidth(); ++x) {
                std::cout << m_data.At(x,y);
            }
            std::cout << std::endl;
        }
    }

    void RunOperations(const std::vector<Operation>& operations) {
        for (auto op : operations) {
            RunOperation(op);
        }
    }

    void RunOperation(Operation op) {
        if (op.type == OperationType::Row) {
            PaintRow(op.position, op.color);
        } else if (op.type == OperationType::Column) {
            PaintColumn(op.position, op.color);
        }
    }

    std::vector<size_t> CountColors() {
        std::vector<size_t> counts;

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

private:

    Grid2D<size_t> m_data;

};

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

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


    Painting p(width, height);

    p.RunOperations(operations);

    //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: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 3

Group: 1, 3, 4

Verdict: ACCEPTED

Test 4

Group: 2, 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 5

Group: 2, 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 6

Group: 3, 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 7

Group: 3, 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 8

Group: 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 9

Group: 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 10

Group: 1, 3, 4

Verdict: WRONG ANSWER

Test 11

Group: 1, 3, 4

Verdict: WRONG ANSWER

Test 12

Group: 2, 4

Verdict: RUNTIME ERROR

Test 13

Group: 2, 4

Verdict: RUNTIME ERROR

Test 14

Group: 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 15

Group: 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 16

Group: 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

Test 17

Group: 4

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc