Maalaus

input/code.cpp: In member function 'void Painting::Print()':
input/code.cpp:138:27: warning: comparison of integer expressions of different signedness: 'int' and 'size_t' {aka 'long unsigned int'} [-Wsign-compare]
  138 |         for (int y = 0; y < m_height; ++y) {
      |                         ~~^~~~~~~~~~
input/code.cpp:139:31: warning: comparison of integer expressions of different signedness: 'int' and 'size_t' {aka 'long unsigned int'} [-Wsign-compare]
  139 |             for (int x = 0; x < m_width; ++x) {
      |                             ~~^~~~~~~~~
input/code.cpp:142:38: warning: comparison of integer expressions of different signedness: 'const size_t' {aka 'const long unsigned int'} and 'int' [-Wsign-compare]
  142 |                     if (row.position == y && row.removals.count(x) == 0) {
      |                         ~~~~~~~~~~~~~^~~~
input/code.cpp:147:38: warning: comparison of integer expressions of different signedness: 'const size_t' {aka 'const long unsigned i...

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <array>
#include <unordered_set>
#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;
    uint8_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) {}

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

    void RunOperation(Operation op) {
        if (op.type == OperationType::Row) {
            Line row;
            row.position = op.position;
            row.color = op.color;
            bool skip = false;
            for (auto& iRow : m_rows) {
                if (iRow.position == row.position) {
                    iRow.removals.clear();
                    iRow.color = row.color;
                    skip = true;
                    break;
                }
            }
            if (!skip) { 
                m_rows.push_back(row);
            }
            for (auto& col : m_columns) {
                col.removals.insert(row.position);
            }
        } else if (op.type == OperationType::Column) {
            Line col;
            col.position = op.position;
            col.color = op.color;
            bool skip = false;
            for (auto& iCol : m_columns) {
                if (iCol.position == col.position) {
                    iCol.removals.clear();
                    iCol.color = col.color;
                    skip = true;
                    break;
                }
            }
            if (!skip) { 
                m_columns.push_back(col);
            }
            for (auto& row : m_rows) {
                row.removals.insert(col.position);
            }
        }
    }

    std::vector<size_t> CountColors() {

        std::vector<size_t> counts;
        counts.resize(m_numColors, 0);

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

        for (const auto& col : m_columns) {
            if (col.color == 0) continue;
            counts.at(col.color-1) += m_height - col.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 counts;
    }

    void Print() {
        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.position == y && row.removals.count(x) == 0) {
                        color = row.color;
                    }
                }
                for (const auto& col : m_columns) {
                    if (col.position == x && col.removals.count(y) == 0) {
                        color = col.color;
                    }
                }
                std::cout << color;
            }
            std::cout << std::endl;
        }
    }

private:

    std::vector<Line> m_rows;
    std::vector<Line> m_columns;

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

    //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: TIME LIMIT EXCEEDED

Test 5

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 6

Group: 3, 4

Verdict: WRONG ANSWER

Test 7

Group: 3, 4

Verdict: WRONG ANSWER

Test 8

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 1, 3, 4

Verdict: ACCEPTED

Test 11

Group: 1, 3, 4

Verdict: ACCEPTED

Test 12

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 4

Verdict: TIME LIMIT EXCEEDED