Submission #61302590

---

Source Code Expand

#line 1 "main.cpp"
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

#include <cstdio>
#include <cassert>
#include <cmath>
#include <cstring>
#include <string>
#include <functional>
#include <stack>
#include <utility>
#include <queue>
#include <algorithm>
#include <execinfo.h>
#include <iostream>
#include <set>
#include <numeric>
#include <map>
using namespace std;
using ll = long long int;

#ifdef DEBUG
#define STDERR(...) fprintf(stderr, __VA_ARGS__);
#define ASSERT_OVERLOAD(e1,e2,NAME,...) NAME
#define ASSERT_1(x) assert_with_backtrace((x))
#define ASSERT_2(x, y) assert_with_backtrace((x), (y))
#define ASSERT(...) ASSERT_OVERLOAD(__VA_ARGS__, ASSERT_2, ASSERT_1)(__VA_ARGS__)
#define DEBUG_PRINT(...) fprintf(stderr, __VA_ARGS__), printf(__VA_ARGS__)
#else
#define STDERR(...)
#define ASSERT(...)
#define DEBUG_PRINT(...)
#endif

// assert で落ちたときにバックトレースする (`-g -rdynamic` が必要)
// デバッグモードでのみ有効
void assert_with_backtrace(bool condition, std::string error_msg="") {
    if(!condition) {
        void* callstack[256];
        int i, frames = backtrace(callstack, 256);
        char** strs = backtrace_symbols(callstack, frames);
        for (i = 0; i < frames; ++i) {
            fprintf(stderr, "%s\n", strs[i]);
        }
        free(strs);
        fprintf(stderr, "%s\n", error_msg.c_str());
        ASSERT(false);
    }
}

template <typename Tp>
bool chmin(Tp& a, const Tp& b) {
    if(a > b) {
        a = b;
        return true;
    } else {
        return false;
    }
}
template <typename Tp>
bool chmax(Tp& a, const Tp& b) {
    if(a < b) {
        a = b;
        return true;
    } else {
        return false;
    }
}

#line 1 "/home/tsutaj/Documents/compro/cpp_library/marathon/timer.cpp"
#include <chrono>

class Timer {
    chrono::high_resolution_clock::time_point start, end;
    double limit;  // 秒数を指定

public:
    Timer() {
        start = chrono::high_resolution_clock::now();
    }
    Timer(double l) {
        start = chrono::high_resolution_clock::now();
        limit = l;
    }

    double getTime() {
        end = chrono::high_resolution_clock::now();
        return chrono::duration<double>(end - start).count();
    }

    bool isTimeOver() {
        if (getTime() > limit) {
            return true;
        }
        return false;
    }

    double getLimit() { return limit; }
    void setLimit(double l) {
        limit = l;
    }
    void setStart() { start = chrono::high_resolution_clock::now(); }
};
#line 1 "/home/tsutaj/Documents/compro/cpp_library/marathon/rand.cpp"
// [lb, ub] の閉区間内の値をランダムに返す構造体
#include <random>
#include <limits>

struct Rand {
public:
    Rand() = default;
    Rand(std::mt19937::result_type seed) : eng(seed) {}

    uint32_t NextUInt(uint32_t lb, uint32_t ub) {
        return std::uniform_int_distribution<uint32_t>{lb, ub}(eng);
    }
    uint32_t NextUInt() {
        return std::uniform_int_distribution<uint32_t>{0, std::numeric_limits<uint32_t>::max()}(eng);
    }

    int32_t NextInt(int32_t lb, int32_t ub) {
        return std::uniform_int_distribution<int32_t>{lb, ub}(eng);
    }
    int32_t NextInt() {
        return std::uniform_int_distribution<int32_t>{0, std::numeric_limits<int32_t>::max()}(eng);
    }

    uint64_t NextULong(uint64_t lb, uint64_t ub) {
        return std::uniform_int_distribution<uint64_t>{lb, ub}(eng);
    }
    uint64_t NextULong() {
        return std::uniform_int_distribution<uint64_t>{0, std::numeric_limits<uint64_t>::max()}(eng);
    }

    int64_t NextLong(int64_t lb, int64_t ub) {
        return std::uniform_int_distribution<int64_t>{lb, ub}(eng);
    }
    int64_t NextLong() {
        return std::uniform_int_distribution<int64_t>{0, std::numeric_limits<int64_t>::max()}(eng);
    }

    double NextDouble(double lb = 0.0, double ub = 1.0) {
        return std::uniform_real_distribution<double>{lb, ub}(eng);
    }
private:
    std::mt19937 eng{std::random_device{}()};
};
#line 1 "/home/tsutaj/Documents/compro/cpp_library/marathon/chokudai_search.cpp"
/**
 * @brief chokudai サーチ
 * @docs docs/marathon/chokudai_search.md
 */

#line 1 "/home/tsutaj/Documents/compro/cpp_library/marathon/interval_heap.cpp"
template <typename Tp>
class IntervalHeap {
   public:
    template <class Iterator>
    IntervalHeap(Iterator first, Iterator last) : data_(first, last) {
        make_heap();
    }
    IntervalHeap() = default;

    size_t size() const { return data_.size(); }
    void clear() { data_.clear(); }
    void emplace(const Tp& val) {
        data_.push_back(val);
        up(size() - 1);
    }
    void push(const Tp& val) { emplace(val); }
    const Tp& top_min() const { return data_[size() >= 2]; }
    const Tp& top_max() const { return data_[0]; }
    void pop_min() {
        if(size() <= 2) {
            data_.pop_back();
        } else {
            swap(data_[1], data_.back());
            data_.pop_back();
            const size_t k = down(1);
            up(k);
        }
    }
    void pop_max() {
        if(size() <= 1) {
            data_.pop_back();
        } else {
            swap(data_[0], data_.back());
            data_.pop_back();
            const size_t k = down(0);
            up(k);
        }
    }

   private:
    vector<Tp> data_;
    inline size_t to_k_max(size_t k) { return k & ~1; }
    inline size_t to_k_min(size_t k) { return k | 1; }
    inline size_t get_parent(size_t k, bool is_max) { return (((k >> 1) - 1) & ~1) | (is_max ? 0 : 1); }

    size_t down(size_t k) {
        const size_t s = size();
        if(k & 1) {
            // min heap
            while(true) {
                const size_t cl = (k << 1) + 1;
                const size_t cr = (k << 1) + 3;
                if(cl >= s) break;
                const size_t c = (cr >= s || data_[cl] < data_[cr]) ? cl : cr;
                if(data_[c] < data_[k]) {
                    swap(data_[k], data_[c]);
                    k = c;
                } else {
                    break;
                }
            }
        } else {
            // max heap
            while(true) {
                const size_t cl = (k << 1) + 2;
                const size_t cr = (k << 1) + 4;
                if(cl >= s) break;
                const size_t c = (cr >= s || data_[cr] < data_[cl]) ? cl : cr;
                if(data_[k] < data_[c]) {
                    swap(data_[k], data_[c]);
                    k = c;
                } else {
                    break;
                }
            }
        }
        return k;
    }
    void up(size_t k, size_t root = 1) {
        const size_t k_max = to_k_max(k);
        const size_t k_min = to_k_min(k);
        if(k_min < size() && data_[k_max] < data_[k_min]) {
            swap(data_[k_max], data_[k_min]);
            k ^= 1;
        }

        size_t p;
        // max heap
        while(root < k && data_[p = get_parent(k, true)] < data_[k]) {
            swap(data_[k], data_[p]);
            k = p;
        }
        // min heap
        while(root < k && data_[k] < data_[p = get_parent(k, false)]) {
            swap(data_[k], data_[p]);
            k = p;
        }
    }
    void make_heap() {
        for(size_t i = size(); i--;) {
            if((i & 1) && data_[i - 1] < data_[i]) {
                swap(data_[i - 1], data_[i]);
            }
            size_t k = down(i);
            up(k, i);
        }
    }
};
#line 7 "/home/tsutaj/Documents/compro/cpp_library/marathon/chokudai_search.cpp"

template <class State, class Timer>
class ChokudaiSearch {
   public:
    ChokudaiSearch() : num_iter_(-1) {}
    void init(int max_turns, double search_time, int time_check_iter) {
        states_.resize(max_turns + 1);
        search_time_ = search_time;
        num_iter_ = 0;
        time_check_iter_ = time_check_iter;
        max_num_states_.resize(max_turns, 1 << 30);
    }
    void set_max_num_states(int max_num_state) {
        fill(max_num_states_.begin(), max_num_states_.end(), max_num_state);
    }
    void set_max_num_states(const vector<int> &max_num_states) {
        assert(max_num_states.size() == max_num_states_.size());
        max_num_states_ = max_num_states;
    }
    void register_state(int turns, const State &state) {
        states_[turns].emplace(state);
        while(states_[turns].size() > max_num_states_[turns]) {
            states_[turns].pop_max();
        }
    }
    void search(Timer &timer, const auto &add_next_states) {
        assert(num_iter_ >= 0);
        const double start_time = timer.getTime();
        for(num_iter_ = 0;; num_iter_++) {
            for(int turns = 0; turns + 1 < (int)states_.size(); turns++) {
                if(timer.getTime() - start_time > search_time_) {
                    goto TIME_OVER;
                }
                if(states_[turns].size() == 0) continue;
                State state = states_[turns].top_min();
                states_[turns].pop_min();
                add_next_states(turns, state);
            }
        }
    TIME_OVER:;
        fprintf(stderr, "chokudai search: num_iter = %d\n", num_iter_);
    }
    const State &get_best_state() const { return states_.back().top_min(); }

   private:
    double search_time_;
    int num_iter_;
    int time_check_iter_;
    vector<IntervalHeap<State>> states_;
    vector<int> max_num_states_;
};
#line 74 "main.cpp"
// #include "xrand1.h"
Rand rnd(35023503980LL);
Timer timer;

constexpr int MAX_SET_SIZE = 3;
struct Parameters {
    double time_limit = 1.95;
} params;

constexpr int N = 9;
constexpr int M = 20;
constexpr int S = 3;
constexpr int K = 81;
constexpr int MOD = 998244353;
int stamps[M][S][S];

int mod_add(int v1, int v2) {
    int ret = v1 + v2;
    while(ret >= MOD) ret -= MOD;
    while(ret < 0) ret += MOD;
    return ret;
}
int mod_sub(int v1, int v2) {
    int ret = v1 - v2;
    while(ret < 0) ret += MOD;
    return ret;
}

struct Board {
public:
    void input() {
        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                scanf("%d", &board[i][j]);
            }
        }
    }
    int* operator[](int r) { return board[r]; }
    const int* operator[](int r) const { return board[r]; }
    int cell_score(int r, int c) const { return board[r][c]; }
    ll calc_score_naive() const {
        ll score = 0;
        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                score += cell_score(i, j);
            }
        }
        return score;
    }
private:
    int board[N][N];
};

struct Operation {
    int r, c, t;
    Operation() = default;
    Operation(int r, int c, int t) : r(r), c(c), t(t) {}
};

struct State {
public:
    Board board;
    int ops;
    ll score;
    Operation operations[K];

    State() = default;
    State(const Board& board) : board(board), ops(0), score(board.calc_score_naive()) {}
    inline bool can_add() { return ops < K; }
    inline bool can_del() { return ops > 0; }
    void dump_answer() const {
        printf("%d\n", ops);
        for(int i=0; i<ops; i++) {
            auto [r, c, t] = operations[i];
            printf("%d %d %d\n", t, r, c);
        }
    }

    void add(int r, int c, int t) {
        for(int dr=0; dr<S; dr++) {
            for(int dc=0; dc<S; dc++) {
                ASSERT(r + dr < N);
                ASSERT(c + dc < N);

                score -= board[r + dr][c + dc];
                board[r + dr][c + dc] = mod_add(board[r + dr][c + dc], stamps[t][dr][dc]);
                score += board[r + dr][c + dc];
            }
        }
        operations[ops++] = Operation(r, c, t);
    }
    void del(int k) {
        const auto& [r, c, t] = operations[k];
        for(int dr=0; dr<S; dr++) {
            for(int dc=0; dc<S; dc++) {
                ASSERT(r + dr < N);
                ASSERT(c + dc < N);
                score -= board[r + dr][c + dc];
                board[r + dr][c + dc] = mod_sub(board[r + dr][c + dc], stamps[t][dr][dc]);
                score += board[r + dr][c + dc];
            }
        }
        swap(operations[k], operations[ops - 1]);
        ops--;
    }
};

void input(Board& initial_board) {
    int n, m, k; scanf("%d%d%d", &n, &m, &k);
    initial_board.input();
    for(int i=0; i<M; i++) {
        for(int r=0; r<S; r++) {
            for(int c=0; c<S; c++) {
                scanf("%d", &stamps[i][r][c]);
            }
        }
    }
}

bool need_update(ll cur_score, ll nxt_score, double temp = 1e-9) {
    ll score_diff = nxt_score - cur_score;
    // return score_diff > 0;
    return rnd.NextDouble() < exp(score_diff / temp);
}

void solve1(const State& initial_state) {
    State cur_state = initial_state;
    int num_iter = 0;
    DEBUG_PRINT("initial score: %lld\n", cur_state.score);
    // 5.0x10^8 * 9 = 4.5*10^9
    double start_temp = 1.0e9;
    double end_temp = 0.0;
    double start_time = timer.getTime();
    double time_ratio = (timer.getTime() - start_time) / (params.time_limit - start_time);
    double cur_temp = start_temp + (end_temp - start_temp) * time_ratio;
    State best_state = cur_state;
    ll best_score = cur_state.score;
    for(; ; num_iter++) {
        if (num_iter % 10000 == 0) {
            if (timer.isTimeOver()) {
                break;
            }
            time_ratio = (timer.getTime() - start_time) / (params.time_limit - start_time);
            cur_temp = start_temp + (end_temp - start_temp) * time_ratio;
        }
        int kind = rnd.NextInt(0, 2);
        if (kind == 0) {
            if (!cur_state.can_add()) continue;
            int r = rnd.NextInt(0, N - S);
            int c = rnd.NextInt(0, N - S);
            int t = rnd.NextInt(0, M - 1);

            ll cur_score = cur_state.score;
            cur_state.add(r, c, t);
            ll nxt_score = cur_state.score;
            if (need_update(cur_score, nxt_score, cur_temp)) {
                // do nothing
            } else {
                int k = cur_state.ops - 1;
                cur_state.del(k);
            }
        } else if (kind == 1) {
            if (!cur_state.can_del()) continue;
            int k = rnd.NextInt(0, cur_state.ops - 1);
            auto [r, c, t] = cur_state.operations[k];

            ll cur_score = cur_state.score;
            cur_state.del(k);
            ll nxt_score = cur_state.score;
            ll score_diff = nxt_score - cur_score;
            if (need_update(cur_score, nxt_score, cur_temp)) {
                // do nothing
            } else {
                cur_state.add(r, c, t);
            }
        } else if (kind == 2) {
            if (!cur_state.can_del()) continue;
            int k = rnd.NextInt(0, cur_state.ops - 1);
            auto [r1, c1, t1] = cur_state.operations[k];

            int r2 = rnd.NextInt(0, N - S);
            int c2 = rnd.NextInt(0, N - S);
            int t2 = rnd.NextInt(0, M - 1);

            ll cur_score = cur_state.score;
            cur_state.del(k);
            cur_state.add(r2, c2, t2);
            ll nxt_score = cur_state.score;
            if (need_update(cur_score, nxt_score, cur_temp)) {
                // do nothing
            } else {
                cur_state.del(cur_state.ops - 1);
                cur_state.add(r1, c1, t1);
            }
        } else if (kind == 3) {
            if (!cur_state.can_add()) continue;
            int num_add = rnd.NextInt(1, min(5, K - cur_state.ops));
            int r = rnd.NextInt(0, N - S);
            int c = rnd.NextInt(0, N - S);

            ll cur_score = cur_state.score;
            for(int i=0; i<num_add; i++) {
                int t = rnd.NextInt(0, M - 1);
                cur_state.add(r, c, t);
            }
            ll nxt_score = cur_state.score;
            if (need_update(cur_score, nxt_score, cur_temp)) {
                // do nothing
            } else {
                for(int i=0; i<num_add; i++) {
                    cur_state.del(cur_state.ops - 1);
                }
            }
        }
        if (cur_state.score > best_score) {
            best_score = cur_state.score;
            best_state = cur_state;
        }
    }
    DEBUG_PRINT("num_iter = %d, final score: %lld\n", num_iter, best_state.score);
    best_state.dump_answer();
}

const int vec2int(const vector<int>& vec) {
    int ret = 0;
    for(int i=0; i<MAX_SET_SIZE; i++) {
        int k = i < vec.size() ? vec[i] : M;
        ret = ret * (M + 1) + k;
    }
    return ret;
}
const vector<int> int2vec(int val) {
    vector<int> vec;
    for(int i=0; i<MAX_SET_SIZE; i++) {
        int k = val % (M + 1);
        if (k < M) vec.emplace_back(k);
        val /= (M + 1);
    }
    return vec;
}

vector< pair<int, vector<int>> > stamps_candidate;
vector<int> idx2int;
void precalc() {
    auto dfs = [&](auto&& self, vector<int>& vec, int k, int sum) -> void {
        if (vec.size() > MAX_SET_SIZE) return;
        if (k == M) {
            if (!vec.empty()) {
                stamps_candidate.emplace_back(sum, vec);
            }
            return;
        }

        self(self, vec, k+1, sum);
        vec.push_back(k);
        self(self, vec, k, (sum + stamps[k][0][0]) % MOD);
        vec.pop_back();
    };
    vector<int> empty_vec;
    dfs(dfs, empty_vec, 0, 0);

    sort(stamps_candidate.begin(), stamps_candidate.end(), [&](const auto& p1, const auto& p2) {
        if (p1.first != p2.first) return p1.first < p2.first;
        return p1.second.size() < p2.second.size();
    });
    vector< pair<int, vector<int>> > new_stamps_candidate;
    for(const auto& [sum, vec] : stamps_candidate) {
        bool add = false;
        add |= new_stamps_candidate.empty();
        add |= !add && new_stamps_candidate.back().first != sum;
        add |= !add && new_stamps_candidate.back().first == sum && new_stamps_candidate.back().second.size() == vec.size();
        if (add) {
            new_stamps_candidate.emplace_back(sum, vec);
            idx2int.emplace_back(vec2int(vec));
        }
    }
    // fprintf(stderr, "new_stamps_candidate size = %zu\n", new_stamps_candidate.size());
    // for(auto& [sum, vec] : new_stamps_candidate) {
    //     fprintf(stderr, "sum = %d, vec = {", sum);
    //     for(int i=0; i<vec.size(); i++) {
    //         fprintf(stderr, "%d%c", vec[i], i+1 == vec.size() ? '}' : ',');
    //     }
    //     fprintf(stderr, "\n");
    // }
    swap(stamps_candidate, new_stamps_candidate);
}

struct CSState {
    State s;
    ll score;
    ll decided_sum;
    CSState() = default;
    bool operator<(const CSState &other) const {
        return score < other.score;
    }
    CSState(const State &s, ll score, ll decided_sum) : s(s), score(score), decided_sum(decided_sum) {}
};

void solve2(const State& initial_state) {
    auto extract = [&](const State& state, int r, int c) {
        int n_dr = (r == 6 ? 3 : 1);
        int n_dc = (c == 6 ? 3 : 1);
        ll res = 0;
        for(int dr=0; dr<n_dr; dr++) {
            for(int dc=0; dc<n_dc; dc++) {
                res += state.board[r + dr][c + dc];
            }
        }
        return res;
    };

    ChokudaiSearch<CSState, Timer> chokudai_search;
    chokudai_search.init(50, timer.getLimit() - timer.getTime(), 100);
    chokudai_search.register_state(0, CSState{initial_state, 0LL, 0LL});
    chokudai_search.set_max_num_states(3000);

    vector<int> limit_k_vec, num_neighbors_vec;
    for(int stage=0, limit_k=3; stage<49; stage++) {
        int r = stage / 7, c = stage % 7;
        bool is_edge = (r == 6 || c == 6);
        int add_k = 1;
        if (r == 6 && c == 6) add_k = 6;
        else if (r == 6 || c == 6) add_k = 3;
        limit_k += add_k;
        limit_k_vec.emplace_back(limit_k);
        const int num_neighbors = add_k == 1 ? 100 : add_k == 3 ? 150 : 200;
        num_neighbors_vec.emplace_back(num_neighbors);
    }

    auto add_next_states = [&](int actual_turns, CSState& state) {
        const int stage = actual_turns - (actual_turns == 49);
        const int r = stage / 7;
        const int c = stage % 7;
        const bool is_edge = (r == 6 || c == 6);
        int target = MOD - 1 - state.s.board[r][c];
        int idx = upper_bound(stamps_candidate.begin(), stamps_candidate.end(), make_pair(target, vector<int>{M})) - stamps_candidate.begin();
        idx--;

        {
            ll n_decided_sum = state.decided_sum + extract(state.s, r, c);
            ll n_score = stage < 48 ? n_decided_sum : state.s.score;
            n_score -= 1LL * state.s.ops * 30000000;
            chokudai_search.register_state(actual_turns + 1, CSState(state.s, -n_score, n_decided_sum)); // 何もしない
        }
        for(int iter=0, ok=true; iter<num_neighbors_vec[stage] && ok;) {
            if (idx < 0) idx = stamps_candidate.size() - 1;
            while (idx >= stamps_candidate.size()) idx--;
            const auto& [sum, vec] = stamps_candidate[idx];
            if (state.s.ops + vec.size() <= limit_k_vec[stage]) {
                iter++;
                for(int i=0; i<(int)vec.size(); i++) {
                    state.s.add(r, c, vec[i]);
                }
                if (is_edge || state.s.board[r][c] >= 700000000) {
                    ll n_decided_sum = state.decided_sum + extract(state.s, r, c);
                    ll n_score = stage < 48 ? n_decided_sum : state.s.score;
                    n_score -= 1LL * state.s.ops * 30000000;
                    chokudai_search.register_state(actual_turns + 1, CSState(state.s, -n_score, n_decided_sum));
                } else {
                    ok = false;
                }
                for(int i=0; i<(int)vec.size(); i++) {
                    state.s.del(state.s.ops - 1);
                }
            }
            idx--;
        }
    };
    chokudai_search.search(timer, add_next_states);
    const State& best_state = chokudai_search.get_best_state().s;
    fprintf(stderr, "best_state score = %lld\n", best_state.score);
    best_state.dump_answer();
}

int main() {
    timer.setStart();
    timer.setLimit(params.time_limit);
    Board initial_board;
    input(initial_board);
    precalc();

    State initial_state(initial_board);
    // solve1(initial_state);
    solve2(initial_state);
    fprintf(stderr, "end time: %lf\n", timer.getTime());
    return 0;
}

Submission Info

Compile Error

main.cpp: In function ‘void solve1(const State&)’:
main.cpp:243:16: warning: unused variable ‘score_diff’ [-Wunused-variable]
main.cpp: At global scope:
main.cpp:297:1: warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
main.cpp: In function ‘const int vec2int(const std::vector<int>&)’:
main.cpp:300:19: warning: comparison of integer expressions of different signedness: ‘int’ and ‘std::vector<int>::size_type’ {aka ‘long unsigned int’} [-Wsign-compare]
main.cpp: In function ‘void solve2(const State&)’:
main.cpp:393:14: warning: unused variable ‘is_edge’ [-Wunused-variable]
main.cpp: In lambda function:
main.cpp:420:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘std::vector<std::pair<int, std::vector<int> > >::size_type’ {aka ‘long unsigned int’} [-Wsign-compare]
main.cpp:422:42: warning: comparison of integer expressions of different signedness: ‘std::vector<int>::size_type’ {aka ‘long unsigned int’} and ‘__gnu_cxx::__alloc_traits<std::allocator<int>, int>::value_type’ {aka ‘int’} [-Wsign-compare]
/home/tsutaj/Documents/compro/cpp_library/marathon/chokudai_search.cpp: In instantiation of ‘void ChokudaiSearch<State, Timer>::register_state(int, const State&) [with State = CSState; Timer = Timer]’:
main.cpp:387:35:   required from here
/home/tsutaj/Documents/compro/cpp_library/marathon/chokudai_search.cpp:28:37: warning: comparison of integer expressions of different signedness: ‘size_t’ {aka ‘long unsigned int’} and ‘__gnu_cxx::__alloc_traits<std::allocator<int>, int>::value_type’ {aka ‘int’} [-Wsign-compare]
main.cpp: In function ‘void input(Board&)’:
main.cpp:182:23: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
main.cpp:187:22: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
main.cpp: In member function ‘void Board::input()’:
main.cpp:107:22: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]

Judge Result