Maalarit

input/code.cpp: In function 'int find_painters(std::map<int, int>, bool)':
input/code.cpp:13:22: warning: NULL used in arithmetic [-Wpointer-arith]
     if (is_bottom == NULL && boards.size() == 1) {
                      ^
input/code.cpp:18:29: warning: NULL used in arithmetic [-Wpointer-arith]
     } else if (is_bottom == NULL && boards.size() == 2) {
                             ^
input/code.cpp: In function 'int main()':
input/code.cpp:164:14: warning: unused variable 'cost' [-Wunused-variable]
     for(auto cost: costs) {
              ^
input/code.cpp:142:27: warning: 'total_cost' may be used uninitialized in this function [-Wmaybe-uninitialized]
         total_cost += cost;
                           ^

#include <iostream>
#include <vector>
#include <map>

int number_of_boards;
std::map<int, int> board_painters; // board:painter=1,2,3
int costs[3] = {0, 0, 0};

std::map<int, int> board_set_bottom;
std::map<int, int> board_set_top;

int find_painters(std::map<int, int> boards, bool is_bottom = NULL) {
    if (is_bottom == NULL && boards.size() == 1) {
        std::pair<int, int> board = std::pair<int, int>(boards.begin()->first, boards.begin()->second);
        costs[0] = board.second;
        board_painters.insert(std::pair<int, int>(board.first, 1));
        return 0;
    } else if (is_bottom == NULL && boards.size() == 2) {
        std::pair<int, int> board_one = std::pair<int, int>(boards.begin()->first, boards.begin()->second);
        std::pair<int, int> board_two = std::pair<int, int>(boards.rbegin()->first, boards.rbegin()->second);
        costs[0] = board_one.second;
        costs[1] = board_two.second;
        board_painters.insert(std::pair<int, int>(board_one.first, 1));
        board_painters.insert(std::pair<int, int>(board_two.first, 2));
        return 0;
    }
    
    std::pair<int, int> tallestBoard = std::pair<int, int>(boards.rbegin()->first, boards.rbegin()->second);
    
    for(auto board: boards) {
        if (board.second > tallestBoard.second) {
            tallestBoard = board;
        }
    }
    
    int tallestLocation = tallestBoard.first;
    int tallestHeight = tallestBoard.second;
    
    if (tallestLocation == boards.begin()->first && is_bottom == false) {
        std::map<int, int> boards_subset = boards;
        boards_subset.erase(boards_subset.begin()->first);
        tallestBoard = std::pair<int, int>(boards_subset.rbegin()->first, boards_subset.rbegin()->second);
        tallestLocation = tallestBoard.first;
        tallestHeight = tallestBoard.second;
    } else if (tallestLocation == boards.rbegin()->first && is_bottom == true) {
        std::map<int, int> boards_subset = boards;
        boards_subset.erase(boards_subset.rbegin()->first);
        tallestBoard = *(boards_subset.rbegin());
        tallestLocation = tallestBoard.first;
        tallestHeight = tallestBoard.second;
    }
    board_painters.insert(std::pair<int, int>(tallestLocation, 3));
    if (tallestHeight > costs[2]) {
        costs[2] = tallestHeight;
    }
    
    board_set_bottom.clear();
    board_set_top.clear();
    
    for(auto board: boards) {
        if (board.first < tallestLocation) {
            board_set_bottom.insert(std::pair<int, int>(board.first, board.second));
        } else if (board.first > tallestLocation) {
            board_set_top.insert(std::pair<int, int>(board.first, board.second));
        }
    }
    
    std::vector<std::map<int, int>> board_sets;
    board_sets.push_back(board_set_bottom);
    board_sets.push_back(board_set_top);
    
    for(auto board_set: board_sets) {
        int set_size = board_set.size();
        if (set_size == 0) {
            continue;
        }
        if (set_size > 2) {
            if (board_set == board_set_bottom) {
                find_painters(board_set, true);
            } else {
                find_painters(board_set, false);
            }
        } else if (board_set.rbegin()->first == number_of_boards && board_set == board_set_top && set_size != 1) {
            find_painters(board_set, false);
        } else if (board_set.begin()->first == 1 && board_set == board_set_bottom && set_size != 1) {
            find_painters(board_set, true);
        } else if (set_size == 2) {
            std::pair<int, int> board_one = std::pair<int, int>(board_set.begin()->first, board_set.begin()->second);
            std::pair<int, int> board_two = std::pair<int, int>(board_set.rbegin()->first, board_set.rbegin()->second);
            int board_one_location = board_one.first;
            int board_two_location = board_two.first;
            int board_one_height = board_one.second;
            int board_two_height = board_two.second;
            if (board_one.second >= board_two.second) {
                board_painters.insert(std::pair<int, int>(board_one_location, 2));
                board_painters.insert(std::pair<int, int>(board_two_location, 1));
                if (board_one_height > costs[1]) {
                    costs[1] = board_one_height;
                }
                if (board_two_height > costs[0]) {
                    costs[0] = board_two_height;
                }
            } else {
                board_painters.insert(std::pair<int, int>(board_one_location, 1));
                board_painters.insert(std::pair<int, int>(board_two_location, 2));
                if (board_one_height > costs[0]) {
                    costs[0] = board_one_height;
                }
                if (board_two_height > costs[1]) {
                    costs[1] = board_two_height;
                }
            }
        } else { // set_size == 1
            std::pair<int, int> board = *(board_set.rbegin());
            board_painters.insert(std::pair<int, int>(board.first, 2));
            if (board.second > costs[1]) {
                costs[1] = board.second;
            }
        }
    }
    
    
    return 0;
}

int main() {
    std::cin >> number_of_boards;
    
    std::map<int, int> boards;
    int x;
    for(int p = 1; p <= number_of_boards; ++p) {
        std::cin >> x;
        boards.insert(std::pair<int, int>(p, x)); // location, height
    }
    
    find_painters(boards);
    
    int total_cost;
    
    int number_of_painters = 0;
    for(auto cost: costs) {
        total_cost += cost;
        if (cost != 0) {
            number_of_painters += 1;
        }
    }
    
    std::cout << total_cost << " " << number_of_painters << "\n";
    
    int lowest_painter = 3;
    for(auto set: board_painters) {
        if (set.second < lowest_painter) {
            lowest_painter = set.second;
        }
    }
    if (lowest_painter != 1) {
        for(auto set: board_painters) {
            std::pair<int, int> new_set = std::pair<int, int>(set.first, set.second - lowest_painter + 1);
            board_painters.erase(set.first);
            board_painters.insert(new_set);
        }
    }
    
    for(auto cost: costs) {
        //std::cout << cost << "*";
    }
    
    for(auto set: board_painters) {
        std::cout << set.second << " ";
    }
    
    return 0;
}

Test 1

Group: 1

Verdict: WRONG ANSWER

Test 2

Group: 1

Verdict: ACCEPTED

Test 3

Group: 1

Verdict: WRONG ANSWER

Test 4

Group: 1

Verdict: WRONG ANSWER

Test 5

Group: 1

Verdict: WRONG ANSWER

Test 6

Group: 1

Verdict: ACCEPTED

Test 7

Group: 2

Verdict: WRONG ANSWER

Test 8

Group: 2

Verdict: WRONG ANSWER

Test 9

Group: 2

Verdict: WRONG ANSWER

Test 10

Group: 2

Verdict: WRONG ANSWER

Test 11

Group: 2

Verdict: WRONG ANSWER

Test 12

Group: 2

Verdict: ACCEPTED

Test 13

Group: 3

Verdict: WRONG ANSWER

Test 14

Group: 3

Verdict: WRONG ANSWER

Test 15

Group: 3

Verdict: WRONG ANSWER

Test 16

Group: 3

Verdict: WRONG ANSWER

Test 17

Group: 3

Verdict: WRONG ANSWER

Test 18

Group: 3

Verdict: ACCEPTED

Test 19

Group: 4

Verdict: WRONG ANSWER

Test 20

Group: 4

Verdict: WRONG ANSWER

Test 21

Group: 4

Verdict: WRONG ANSWER

Test 22

Group: 4

Verdict: WRONG ANSWER

Test 23

Group: 4

Verdict: WRONG ANSWER

Test 24

Group: 4

Verdict: RUNTIME ERROR