Submission #25081101

---

Source Code Expand

#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define NDEBUG
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>
#include <math.h>
#include <iomanip>
#include <limits>
#include <list>
#include <queue>
#include <tuple>
#include <map>
#include <stack>
#include <set>
#include <bitset>
#include <functional>
#include <chrono>
#include <cassert>
#include <array>
#include <numeric>
#include <random>
using namespace std;
#define fast_io ios_base::sync_with_stdio (false) ; cin.tie(0) ; cout.tie(0) ;
#define ll long long int
#define rep(i,n) for(int i=0; i<(int)(n); i++)
#define reps(i,n) for(int i=1; i<=(int)(n); i++)
#define REP(i,n) for(int i=n-1; i>=0; i--)
#define REPS(i,n) for(int i=n; i>0; i--)
#define MOD (long long int)(1e9+7)
#define INF (int)(1e9)
#define LINF (long long int)(1e18)
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
#define all(v) v.begin(), v.end()
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;

constexpr int WEIGHT_SMALL = 1, WEIGHT_LARGE = 280;
constexpr int ALPHA = 156, GAMMA_LARGE = 10000, GAMMA_SMALL = 1;
constexpr int PROB_POINT_KOTAI = 4, PROB_RANGE_SWAP = 2, PROB_POINT_SWAP = 34;
constexpr int PROB_POINT_INSERT = 3, PROB_RANGE_INSERT = 20, PROB_ADJACENT_SWAP = 33;
constexpr int CHUKAN_TIME_LIMIT = 1354;
constexpr int KEISHA = 47;
constexpr int OPT_KIJUN = 38;
constexpr int OPT_PROB_POINT_SWAP = 70, OPT_PROB_POINT_INSERT = 30, OPT_PROB_ADJACENT_SWAP = 0;
constexpr int SUCCESS_BONUS = 48;
constexpr int YUGU_DELAY_T = 139;
constexpr int LEN_RANGE_SWAP = 100;
constexpr int LEN_RANGE_INSERT = 100;
//未調整
constexpr int NO_CHANGE_UPDATE_BUNSHI = 100;
constexpr int NO_CHANGE_UPDATE_BUNBO = 1000;
//未調整
constexpr double gamma_delta = 1.2;

int M,N,t60,max_T,car_total_num;
int T[40][80] = {}, T_tenchi[80][40] = {};
vector<int> X;
vector<int> car_nums;
vector<int> max_delay;
vector<int> sum_T;

uint32_t xorshift(){
    static uint32_t x = 123456789;
    static uint32_t y = 362436069;
    static uint32_t z = 521288629;
    static uint32_t w = 886751234;
    uint32_t t;
    t = x ^ (x<<11);
    x = y; y = z; z = w;
    w ^= t ^ (t>>8) ^ (w>>19);
    return w;
}

class Timer{
    chrono::system_clock::time_point _start, _end;
    ll _sum = 0, _count = 0;

public:
    void start(){
        _start = chrono::system_clock::now();
    }

    void stop(){
        _end = chrono::system_clock::now();
    }

    void add(){
        const chrono::system_clock::time_point now = chrono::system_clock::now();
        _sum += static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(now - _start).count());
        _count++;
    }

    ll sum(){
        return _sum / 1000;
    }

    string average(){
        if(_count == 0){
            return "NaN";
        }
        return to_string(_sum / 1000 / _count);
    }

    void reset(){
        _start = chrono::system_clock::now();
        _sum = 0;
        _count = 0;
    }

    inline int ms() const{
        const chrono::system_clock::time_point now = chrono::system_clock::now();
        return static_cast<double>(chrono::duration_cast<chrono::microseconds>(now - _start).count() / 1000);
    }

    inline int ns() const{
        const chrono::system_clock::time_point now = chrono::system_clock::now();
        return static_cast<double>(chrono::duration_cast<chrono::microseconds>(now - _start).count());
    }
};

Timer timer, timer1, timer2, timer3, timer4, timer5;

struct Simulator{
    struct Event{
        int t;
        bool is_start;
        int human_id;
        int pi;

        bool operator<(const Event& other) const{
            if(t != other.t){
                return t < other.t;
            }
            if(is_start != other.is_start){
                return is_start > other.is_start;
            }
            return human_id > other.human_id;
        }
    };

    //1000
    vector<Event> event_order;
    vector<int> P;
    bitset<1000> feedback_done_delay;
    //M
    vector<int> delay;
    vector<int> ruiseki_chokines;
    vector<vector<Pii>> will_stopes; //{pi, time}

    //N
    struct Car{
        int remain, num;
    };
    vector<Car> car_infos;
    vector<int> car_finishes;

    int base_chokin = 0;
    int next_ei = 0;
    int delay_sum = 0;
    int last_time = INF;
    bool can_continue = true;
    bool do_pass = false;
    // 前処理としてイベント発生順にソート
    // イベント：ある区間の始端に車が到着、ある区間の終端に車が到着
    // 同時の場合は始端が優先
    Simulator()
    : event_order(M*car_total_num*2), will_stopes(M), delay(M,0), ruiseki_chokines(M, 0), feedback_done_delay(0), car_infos(N), car_finishes(N)
    {
        rep(i,N){
            car_infos[i].remain = car_nums[i];
            car_infos[i].num = car_nums[i];
            car_finishes[i] = 0;
        }
        int idx = 0;
        for(int t = 0; t < car_total_num; ++t){
            for(int j = 0; j < M; ++j){
                event_order[idx++] = {t * t60 + X[j] + 1, true, j, t};
                event_order[idx++] = {t * t60 + X[j+1], false, j, t};
            }
        }
        sort(all(event_order));

        P.reserve(car_total_num);
    }

    void reset(){
        feedback_done_delay = 0;
        rep(i,M){
            will_stopes[i].clear();
        }
        fill(all(delay),0);
        fill(all(max_delay),0);
        fill(all(ruiseki_chokines),0);
        rep(i,M){
            max_delay[i] = X[i+1] - X[i] - 1;
        }
        rep(i,N){
            car_infos[i].remain = car_nums[i];
            car_infos[i].num = car_nums[i];
            car_finishes[i] = 0;
        }
        P.clear();
        P.reserve(car_total_num);

        base_chokin = 0;
        next_ei = 0;
        delay_sum = 0;
        last_time = INF;
        can_continue = true;
        do_pass = false;
    }

    bool operator()(const int choosen_car_id, const bool auto_pass = false){
        assert(can_continue);
        assert(event_order[next_ei].human_id == 0 && event_order[next_ei].is_start);
        assert(choosen_car_id == -1 || car_infos[choosen_car_id].remain > 0);
        if(choosen_car_id == -1 || (auto_pass && get_current_time() + X[M-1] >= max_T)){
            do_pass = true;
            P.emplace_back(-1);
        }else{
            P.emplace_back(choosen_car_id);
            constexpr int human_id = 0;
            car_infos[choosen_car_id].remain--;
            //直前まで発生していたコンベアストップのうち、有効活用できる分を精算する
            int chokin = base_chokin - ruiseki_chokines[human_id];
            ruiseki_chokines[human_id] = base_chokin;
            auto& queue = will_stopes[human_id];
            while(queue.size() > 0){
                queue.front().second -= chokin;
                if(queue.front().second > 0){
                    chokin = 0;
                    break;
                }
                chokin = -queue.front().second;
                queue.erase(queue.begin());
                assert(chokin >= 0);
            }
            //残りでdelay軽減
            delay[human_id] = max(0, delay[human_id] - chokin);
            //はみ出さないかチェック
            int finish_delay = delay[human_id] + T[choosen_car_id][human_id];
            if(finish_delay > max_delay[human_id]){
                const int diff = finish_delay - max_delay[human_id];
                queue.emplace_back(event_order[next_ei].pi, diff);
                finish_delay -= diff;
            }
            //t60回復
            delay[human_id] = max(0, finish_delay - t60);
        }
        ++next_ei;
        for(;
            next_ei < event_order.size() && (event_order[next_ei].human_id != 0 || !event_order[next_ei].is_start);
            ++next_ei){
            const auto& event = event_order[next_ei];
            const int human_id = event.human_id;
            const int car_id = P[event.pi];
            //Todo:大丈夫？(修正するなら他にも何箇所か有るのでそちらも修正)
            if(get_current_time() > max_T) return can_continue = false;
            if(car_id == -1) continue;

            if(event.is_start){
                //直前まで発生していたコンベアストップのうち、有効活用できる分を精算する
                int chokin = base_chokin - ruiseki_chokines[human_id];
                ruiseki_chokines[human_id] = base_chokin;

                auto& queue = will_stopes[human_id];
                while(queue.size() > 0){
                    queue.front().second -= chokin;
                    if(queue.front().second > 0){
                        chokin = 0;
                        break;
                    }
                    chokin = -queue.front().second;
                    queue.erase(queue.begin());
                    assert(chokin >= 0);
                }
                //残りでdelay軽減
                delay[human_id] = max(0, delay[human_id] - chokin);
                //はみ出さないかチェック
                int finish_delay = delay[human_id] + T[car_id][human_id];
                if(finish_delay > max_delay[human_id]){
                    const int diff = finish_delay - max_delay[human_id];
                    queue.emplace_back(event.pi,diff);
                    finish_delay -= diff;
                }
                //t60回復
                delay[human_id] = max(0, finish_delay - t60);

                //製造完了する車のcountを増加
                if(human_id == M - 1){
                    const int finish_time = get_current_time() + finish_delay;
                    if(finish_time <= max_T){
                        car_finishes[car_id]++;
                        last_time = finish_time;
                    }else{
                        return can_continue = false;
                    }
                }
            }else{
                //直前まで発生していたコンベアストップのうち、有効活用できる分を精算する
                int chokin = base_chokin - ruiseki_chokines[human_id];
                ruiseki_chokines[human_id] = base_chokin;

                auto& queue = will_stopes[human_id];
                while(queue.size() > 0){
                    queue.front().second -= chokin;
                     if(queue.front().second > 0){
                        chokin = 0;
                        break;
                    }
                    chokin = -queue.front().second;
                    queue.erase(queue.begin());
                    assert(chokin >= 0);
                }
                //残りでdelay軽減
                delay[human_id] = max(0, delay[human_id] - chokin);

                //queueのcombare_stopが今回のものだったら処理
                if(queue.size() > 0 && queue.front().first == event.pi){
                    feedback_done_delay[event.pi] = true;
                    const int stop_time = queue.front().second;
                    assert(stop_time > 0);
                    delay_sum += stop_time;
                    base_chokin += stop_time;
                    ruiseki_chokines[human_id] = base_chokin;
                    queue.erase(queue.begin());

                    //遅延に反映した結果制限時間をオーバーしたなら終了
                    if(get_current_time() > max_T) return can_continue = false;
                }
            }
        }

        if(next_ei >= event_order.size() || get_current_time() > max_T){
            return can_continue = false;
        }

        return true;
    }

    inline int get_delay_sum() const{
        return delay_sum;
    }

    inline int get_current_time() const{
        if(next_ei == event_order.size()){
            return event_order.back().t + delay_sum;
        }
        assert(next_ei < event_order.size());
        return event_order[next_ei].t + delay_sum;
    }

    inline bitset<1000> get_feedback_delay() const{
        return feedback_done_delay;
    }

    inline int calc_score() const{
        int score = 0;
        if(next_ei < event_order.size() || get_current_time() > max_T || P.size() != car_total_num || do_pass){
            //すべてのeventを処理し終えていない→タスクが残っている
            //eventは処理しきれているが時間をオーバーしている→だめ
            //すべてのcarの処理をそもそもoperator()していない→だめ
            double sc = 0;
            for(int i = 0; i < N; i++){
                sc += sqrt( (double)car_finishes[i] / (double)car_nums[i] );
            }
            sc *= 1000000.0;
            sc /= N;
            score = round(sc);
        }else{
            //すべてのタスクを処理した
            double sc = 1000000.0 * (2.0 - (double)last_time / (double)max_T );
            score = round(sc);
        }
        return score - delay_sum;
    }
};

int challenge(Simulator& sim, const vector<int>& P){
    sim.reset();
    assert(car_total_num == 1000);
    rep(i, car_total_num){
        if(i < P.size()){
            if(!sim(P[i], true)) break;
        }else{
            if(!sim(-1, true)) break;
        }
        
    }
    return sim.calc_score();
}

//制作されない車は投入しない
int brush_up(Simulator& sim, vector<int>& P){
    //投入する個数を二分探索
    int ok = 0;
    int ng = P.size() + 1;
    int best_eval = 0;
    int sum_overs = INF;
    while(ng - ok >= 2){
        int mid = (ok + ng) / 2;
        vector<int> Q(P.begin(), P.begin() + mid);
        const int eval = challenge(sim, Q);
        int count = 0;
        for(const int& fin : sim.car_finishes){
            count += fin;
        }
        if(count == mid){
            ok = mid;
            best_eval = eval;
            sum_overs = sim.delay_sum;
        }else{
            ng = mid;
        }
    }
    // cerr<<"***C sum_overs:"<<sum_overs<<" ***"<<endl;
    // cerr<<"complete_num:"<<ok<<endl;
    assert(ok <= P.size());
    P.resize(ok);
    return best_eval;
}

void input(){
    cin>>N>>M>>t60>>max_T;
    timer.start();
    rep(i,N){
        rep(j,M){
            int t;cin>>t;
            T[i][j] = t;
            T_tenchi[j][i] = t;
        }
    }
    X.push_back(0);
    rep(i,M){
        int x;cin>>x;
        X.push_back(x);
    }
    car_total_num = 0;
    rep(i,N){
        int n;cin>>n;
        car_nums.push_back(n);
        car_total_num += n;
    }
    max_delay.resize(M);
    rep(i,M){
        max_delay[i] = X[i+1] - X[i] - 1;
    }

    sum_T.resize(M);
    rep(i,N){
        rep(j,M){
            sum_T[j] += (T[i][j] - t60) * car_nums[i];
        }
    }
}

void print_P(ostream& os, const vector<int>& P){
    cout<<P.size()<<endl;
    for(auto& p : P){
        cout<<p+1<<" ";
    }
    cout<<endl;
}

vector<int> greedy(const vector<int>& weights, const int gamma){
    const int alpha = ALPHA;
    assert(weights.size() == M);
    vector<int> delays(M);
    const vector<int>& beta_weights = weights;
    bool can_continue = true;
    auto remains = car_nums;
    vector<int> P;
    P.reserve(car_total_num);
    rep(t,car_total_num){
        int best_i = -1;
        int min_pena = INF;
        for(int _t = 0, i = xorshift()%N; _t < N; _t++, (i+1 == N ? i=0 : i++)){
            if(remains[i] == 0) continue;
            int pena = 0;
            rep(j,M){
                //キャパオーバー
                //後半の人にタスクが行き渡ってない場合はペナルティ多め
                //Todo:ちゃんと
                const int keisha = t * t60 + X[j] < X[(M-1)/2] ? KEISHA : 1;
                pena += max(0, delays[j] + T[i][j] - max_delay[j]) * keisha;
            }
            pena *= alpha;
            rep(j,M){
                //回復の無駄遣い
                pena += max(0, t60 - (delays[j] + T[i][j])) * beta_weights[j];
            }

            pena += (car_nums[i] - remains[i]) * gamma;

            if(pena < min_pena){
                min_pena = pena;
                best_i = i;
            }
        }
        assert(best_i != -1);
        rep(j,M){
            delays[j] = min(max_delay[j], delays[j] + T[best_i][j]);
            delays[j] = max(0, delays[j] - t60);
        }
        P.emplace_back(best_i);
        remains[best_i]--;
    }
    return P;
}

vector<int> greedy_feedback(const vector<int>& weights, const int gamma, int& eval){
    eval = 0;
    const int alpha = ALPHA;
    assert(weights.size() == M);
    vector<int> delays(M);
    const vector<int>& beta_weights = weights;
    bool can_continue = true;
    auto remains = car_nums;
    vector<int> P;
    P.reserve(car_total_num);
    rep(t,car_total_num){
        int best_i = -1;
        int min_pena = INF;
        for(int _t = 0, i = xorshift()%N; _t < N; _t++, (i+1 == N ? i=0 : i++)){
            if(remains[i] == 0) continue;
            int pena = 0;
            rep(j,M){
                //キャパオーバー
                //後半の人にタスクが行き渡ってない場合はペナルティ多め
                //Todo:ちゃんと
                const int keisha = t * t60 + X[j] < X[(M-1)/2] ? KEISHA : 1;
                pena += max(0, delays[j] + T[i][j] - max_delay[j]) * keisha;
            }
            pena *= alpha;
            rep(j,M){
                //回復の無駄遣い
                pena += max(0, t60 - (delays[j] + T[i][j])) * beta_weights[j];
            }

            pena += (car_nums[i] - remains[i]) * gamma;

            if(pena < min_pena){
                min_pena = pena;
                best_i = i;
            }
        }
        assert(best_i != -1);
        rep(j,M){
            eval += max(0, delays[j] + T[best_i][j] - max_delay[j]);
            delays[j] = min(max_delay[j], delays[j] + T[best_i][j]);
            delays[j] = max(0, delays[j] - t60);
        }
        P.emplace_back(best_i);
        remains[best_i]--;
    }
    return P;
}

vector<int> greedy_detail(const vector<int>& weights, const int gamma){
    const int alpha = ALPHA;
    assert(weights.size() == M);
    vector<int> delays(M);
    const vector<int>& beta_weights = weights;
    vector<int> P;
    P.reserve(1000);
    bool can_continue = true;
    auto remains = car_nums;
    rep(base_t,car_total_num){
        int base_best_i = -1;
        int base_min_pena = INF;
        auto memo_remains = remains;
        auto memo_delays = delays;
        for(int _base_t = 0, base_i = xorshift()%N; _base_t < N; _base_t++, (base_i+1 == N ? base_i=0 : base_i++)){
            if(memo_remains[base_i] == 0) continue;
            remains = memo_remains;
            delays = memo_delays;
            int sum_pena = 0;
            for(int t = base_t; t < min(base_t + 2, car_total_num); ++t){
                int best_i = -1;
                int min_pena = INF;
                for(int _t = 0, i = xorshift()%N; _t < N; _t++, (i+1 == N ? i=0 : i++)){
                    if(remains[i] == 0) continue;
                    if(t == base_t && i != base_i) continue;
                    int pena = 0;
                    rep(j,M){
                        //キャパオーバー
                        //最後の人にタスクが行き渡ってない場合はペナルティ多め
                        //Todo:ちゃんと
                        const int keisha = t * t60 + X[j] < X[(M-1)/2] ? KEISHA : 1;
                        pena += max(0, delays[j] + T[i][j] - max_delay[j]) * keisha;
                    }
                    pena *= alpha;
                    rep(j,M){
                        //回復の無駄遣い
                        pena += max(0, t60 - (delays[j] + T[i][j])) * beta_weights[j];
                    }

                    pena += (car_nums[i] - remains[i]) * gamma;

                    if(pena < min_pena){
                        min_pena = pena;
                        best_i = i;
                    }
                }
                assert(best_i != -1);
                rep(j,M){
                    delays[j] = min(max_delay[j], delays[j] + T[best_i][j]);
                    delays[j] = max(0, delays[j] - t60);
                }
                remains[best_i]--;
                sum_pena += min_pena * (t == base_t ? 1 : 0.9);
                if(sum_pena >= base_min_pena){
                    break;
                }
            }
            if(sum_pena < base_min_pena){
                base_min_pena = sum_pena;
                base_best_i = base_i;
            }
        }
        assert(base_best_i != -1);
        remains = memo_remains;
        delays = memo_delays;
        rep(j,M){
            delays[j] = min(max_delay[j], delays[j] + T[base_best_i][j]);
            delays[j] = max(0, delays[j] - t60);
        }
        P.emplace_back(base_best_i);
        remains[base_best_i]--;
    }
    return P;
}

vector<int> greedy_detail_feedback(const vector<int>& weights, const int gamma, int& eval){
    eval = 0;
    const int alpha = ALPHA;
    assert(weights.size() == M);
    vector<int> delays(M);
    const vector<int>& beta_weights = weights;
    vector<int> P;
    P.reserve(1000);
    bool can_continue = true;
    auto remains = car_nums;
    rep(base_t,car_total_num){
        int base_best_i = -1;
        int base_min_pena = INF;
        auto memo_remains = remains;
        auto memo_delays = delays;
        for(int _base_t = 0, base_i = xorshift()%N; _base_t < N; _base_t++, (base_i+1 == N ? base_i=0 : base_i++)){
            if(memo_remains[base_i] == 0) continue;
            remains = memo_remains;
            delays = memo_delays;
            int sum_pena = 0;
            for(int t = base_t; t < min(base_t + 2, car_total_num); ++t){
                int best_i = -1;
                int min_pena = INF;
                for(int _t = 0, i = xorshift()%N; _t < N; _t++, (i+1 == N ? i=0 : i++)){
                    if(remains[i] == 0) continue;
                    if(t == base_t && i != base_i) continue;
                    int pena = 0;
                    rep(j,M){
                        //キャパオーバー
                        //最後の人にタスクが行き渡ってない場合はペナルティ多め
                        //Todo:ちゃんと
                        const int keisha = t * t60 + X[j] < X[(M-1)/2] ? KEISHA : 1;
                        pena += max(0, delays[j] + T[i][j] - max_delay[j]) * keisha;
                    }
                    pena *= alpha;
                    rep(j,M){
                        //回復の無駄遣い
                        pena += max(0, t60 - (delays[j] + T[i][j])) * beta_weights[j];
                    }

                    pena += (car_nums[i] - remains[i]) * gamma;

                    if(pena < min_pena){
                        min_pena = pena;
                        best_i = i;
                    }
                }
                assert(best_i != -1);
                rep(j,M){
                    delays[j] = min(max_delay[j], delays[j] + T[best_i][j]);
                    delays[j] = max(0, delays[j] - t60);
                }
                remains[best_i]--;
                sum_pena += min_pena * pow(0.9, t - base_t);
                if(sum_pena >= base_min_pena){
                    break;
                }
            }
            if(sum_pena < base_min_pena){
                base_min_pena = sum_pena;
                base_best_i = base_i;
            }
        }
        assert(base_best_i != -1);
        remains = memo_remains;
        delays = memo_delays;
        rep(j,M){
            eval += max(0, delays[j] + T[base_best_i][j] - max_delay[j]);
            delays[j] = min(max_delay[j], delays[j] + T[base_best_i][j]);
            delays[j] = max(0, delays[j] - t60);
        }
        P.emplace_back(base_best_i);
        remains[base_best_i]--;
    }
    return P;
}

int update(int& best_eval, vector<int>& best_answer, Simulator& sim){
    const int eval = sim.calc_score();
    if(eval > best_eval){
        best_eval = eval;
        best_answer = sim.P;
    }
    return eval;
}

void update(int& best_eval, vector<int>& best_answer, const int eval, const vector<int>& answer){
    if(eval > best_eval){
        best_eval = eval;
        best_answer = answer;
    }
}

constexpr int TIME_LIMIT = 1970;

enum Kinbo{
    POINT_KOTAI, RANGE_SWAP, POINT_SWAP, POINT_INSERT, RANGE_INSERT, ADJACENT_SWAP
};

int yamanobori(Simulator& sim, vector<int>& P){
    // assert(P.size() == car_total_num);
    int best_eval = challenge(sim, P);
    bitset<1000> feedback_done_delay = sim.get_feedback_delay();
    // cerr<<best_eval<<endl;
    // auto best_P = P;
    int g = 0;
    int success_bonus = 0;
    Kinbo before_kinbo;
    vector<int> probs{PROB_POINT_KOTAI, PROB_RANGE_SWAP, PROB_POINT_SWAP, PROB_POINT_INSERT, PROB_RANGE_INSERT, PROB_ADJACENT_SWAP};
    while(timer.ms() < TIME_LIMIT){
        const int rand = xorshift()%100;
        Kinbo kinbo = POINT_SWAP;
        if(success_bonus > 0){
            kinbo = before_kinbo;
        }else{
            int sum = 0;
            rep(i,probs.size()){
                sum += probs[i];
                if(rand < sum){
                    kinbo = Kinbo(i);
                    break;
                }
            }
        }
        before_kinbo = kinbo;
        success_bonus--;

        switch(kinbo){
            case POINT_KOTAI:{
                int pi = xorshift()%((P.size() - 1));
                for(int t = 0; t < YUGU_DELAY_T && !feedback_done_delay[pi]; ++t){
                    pi = xorshift()%((P.size() - 1));
                }
                const auto p = P[pi];
                P.erase(P.begin() + pi);
                P.emplace_back(p);
                const int eval = challenge(sim, P);
                if(eval > best_eval){
                    best_eval = eval;
                    // best_P = P;
                    feedback_done_delay = sim.get_feedback_delay();
                    success_bonus = SUCCESS_BONUS;
                    // cerr<<eval<<"(1点後退)"<<" "<<pi<<endl;
                }else{
                    //復元
                    P.pop_back();
                    P.insert(P.begin() + pi, p);
                }
                break;

            }case RANGE_SWAP:{
                //区間swap
                const int len = xorshift()%LEN_RANGE_SWAP + 1;
                const int l1 = xorshift()%(P.size()-len);
                const int r1 = l1 + len;
                const int l2 = xorshift()%(P.size()-len);
                const int r2 = l2 + len;
                if(!(r1 <= l2 || r2 <= l1)) continue;
                swap_ranges(P.begin() + l1, P.begin() + r1, P.begin() + l2);
                const int eval = challenge(sim, P);
                if(eval > best_eval){
                    best_eval = eval;
                    // best_P = P;
                    feedback_done_delay = sim.get_feedback_delay();
                    // cerr<<eval<<"(区間swap)"<<" "<<l1<<" "<<l2<<" "<<len<<endl;
                    success_bonus = SUCCESS_BONUS;
                }else{
                    //復元
                    swap_ranges(P.begin() + l1, P.begin() + r1, P.begin() + l2);
                }
                break;

            }case POINT_SWAP:{
                //2点swap
                int p1 = xorshift()%P.size();
                for(int t = 0; t < YUGU_DELAY_T && !feedback_done_delay[p1]; ++t){
                    p1 = xorshift()%P.size();
                }
                const int p2 = xorshift()%P.size();
                if(p1 == p2) continue;
                if(P[p1] == P[p2]) continue;
                swap(P[p1], P[p2]);
                const int eval = challenge(sim, P);
                if(eval > best_eval){
                    best_eval = eval;
                    // best_P = P;
                    feedback_done_delay = sim.get_feedback_delay();
                    success_bonus = SUCCESS_BONUS;
                    // cerr<<eval<<"(2点swap)"<<" "<<p1<<" "<<p2<<endl;
                }else{
                    //復元
                    swap(P[p1], P[p2]);
                }
                break;

            }case POINT_INSERT:{
                //1点挿入
                int from = xorshift()%P.size();
                for(int t = 0; t < YUGU_DELAY_T && !feedback_done_delay[from]; ++t){
                    from = xorshift()%P.size();
                }
                int to = xorshift()%P.size();
                if(from == to) continue;
                // //Todo:これはだめでは？
                // if(from > to){
                //     swap(from,to);
                // }
                if(from < to){
                    for(int i = from; i < to; i++){
                        swap(P[i], P[i+1]);
                    }
                }else{
                    for(int i = from; i > to; i--){
                        swap(P[i], P[i-1]);
                    }
                }
                const int eval = challenge(sim, P);
                if(eval > best_eval){
                    best_eval = eval;
                    // best_P = P;
                    feedback_done_delay = sim.get_feedback_delay();
                    success_bonus = SUCCESS_BONUS;
                    // cerr<<eval<<"(1点insert)"<<from<<" "<<to<<endl;
                }else{
                    //復元
                    swap(from,to);
                    if(from < to){
                        for(int i = from; i < to; i++){
                            swap(P[i], P[i+1]);
                        }
                    }else{
                        for(int i = from; i > to; i--){
                            swap(P[i], P[i-1]);
                        }
                    }
                }
                break;
            }case RANGE_INSERT:{
                //区間insert
                const int len = xorshift()%LEN_RANGE_INSERT + 1;
                const int l1 = xorshift()%(P.size()-len);
                const int r1 = l1 + len;
                //todo: 一応高速化する？
                auto memo = P;
                P.erase(P.begin() + l1, P.begin() + r1);
                int to = xorshift()%(P.size()+1);
                P.insert(P.begin() + to, memo.begin() + l1, memo.begin() + r1);

                const int eval = challenge(sim, P);
                if(eval > best_eval){
                    best_eval = eval;
                    // best_P = P;
                    feedback_done_delay = sim.get_feedback_delay();
                    // cerr<<eval<<"(区間insert)"<<" "<<l1<<" "<<r1<<" "<<to<<endl;
                    success_bonus = SUCCESS_BONUS;
                }else{
                    //復元
                    P = memo;
                }
                break;
            }case ADJACENT_SWAP:{
                //隣接swap
                int p1 = xorshift()%(P.size()-1);
                for(int t = 0; t < YUGU_DELAY_T && !feedback_done_delay[p1]; ++t){
                    p1 = xorshift()%(P.size()-1);
                }
                const int p2 = p1 + 1;
                if(P[p1] == P[p2]) continue;
                swap(P[p1], P[p2]);
                const int eval = challenge(sim, P);
                if(eval > best_eval){
                    best_eval = eval;
                    // best_P = P;
                    feedback_done_delay = sim.get_feedback_delay();
                    // success_bonus = SUCCESS_BONUS;
                    // cerr<<eval<<"(隣接swap)"<<" "<<p1<<" "<<p2<<endl;
                }else{
                    //復元
                    swap(P[p1], P[p2]);
                }
                break;
            }
        }
        g++;
    }
    // cerr<<"↓"<<endl;
    // cerr<<best_eval<<endl;
    // cerr<<"yaki_g:"<<g<<endl;

    // P = best_P;
    return best_eval;
}

enum Opt_Kinbo{
    OPT_POINT_SWAP, OPT_POINT_INSERT, OPT_ADJACENT_SWAP
};

vector<int> yamanobori_opt(Simulator& sim, int inp_best_eval, const vector<int>& inp_best_answer){
    vector<int> best_answer;
    best_answer.reserve(car_total_num);
    // 最大数
    int max_car_num = 0;
    int min_complete_time = INF;
    int last_car = 0;
    //Todo:ちゃんとやる 完成しないならmin_complete_timeではなくスコアが重要
    rep(i,N){
        //(max_car_num-1)*t60 + X[M-1]+1 + T[i][M-1] <= max_T
        const int num = min(car_total_num, (max_T - T[i][M-1] - X[M-1]-1) / t60 + 1);
        const int complete_time = (num-1) * t60 + X[M-1]+1 + T[i][M-1];
        if(num > max_car_num){
            max_car_num = num;
            min_complete_time = complete_time;
            last_car = i;
        }else if(num == max_car_num && complete_time < min_complete_time){
            min_complete_time = complete_time;
            last_car = i;
        }
    }
    bool can_complete = max_car_num == 1000;
    {
        vector<int> nums = car_nums;
        for(int t = car_total_num; t > max_car_num; --t){
            int best_i = -1;
            double min_eval = INF;
            rep(i,N){
                if(nums[i] == 0) continue;
                if(i == last_car && nums[i] == 1) continue;
                const double eval = (double)nums[i] / car_nums[i] - (double)(nums[i]-1) / car_nums[i];
                if(eval < min_eval){
                    min_eval = eval;
                    best_i = i;
                }
            }
            nums[best_i]--;
        }
        if(can_complete) {nums[last_car]--; max_car_num--;}
        int best_eval = INF;
        vector<int> weights(M, WEIGHT_SMALL);
        int best_gamma = 1;
        auto memo_car_nums = car_nums;
        for(int gamma = GAMMA_SMALL; gamma <= GAMMA_LARGE; gamma = gamma * gamma_delta + 1){
            car_total_num = max_car_num;
            car_nums = nums;
            int eval;
            vector<int> P = greedy_feedback(weights, gamma, eval);
            if(can_complete) {P.emplace_back(last_car);}
            car_total_num = 1000;
            car_nums = memo_car_nums;
            if(eval < best_eval){
                best_eval = eval;
                best_answer = P;
                best_gamma = gamma;
            }
        }
        {
            car_total_num = max_car_num;
            car_nums = nums;
            int eval;
            vector<int> P = greedy_detail_feedback(weights, best_gamma, eval);
            if(can_complete) {P.emplace_back(last_car);}
            car_total_num = 1000;
            car_nums = memo_car_nums;
            if(eval < best_eval){
                best_eval = eval;
                best_answer = P;
            }
        }
        car_nums = memo_car_nums;
        if(can_complete) {nums[last_car]++; max_car_num++;}
        assert(best_answer.size() <= max_car_num);
        // best_answer.resize(max_car_num);
    }
    vector<vector<int>> best_delays(M, vector<int>(best_answer.size() + 1));
    vector<int> best_overs(best_answer.size() + 1);
    rep(j,M){
        rep(t,best_answer.size()){
            assert(best_answer[t] != -1);
            best_overs[t+1] += max(0, best_delays[j][t] + T_tenchi[j][best_answer[t]] - max_delay[j]);
            best_delays[j][t+1] = min(max_delay[j], best_delays[j][t] + T_tenchi[j][best_answer[t]]);
            if(can_complete && j == M-1 && t+1 == best_answer.size()){
                best_overs[t+1] += best_delays[j][t+1];
            }
            best_delays[j][t+1] = max(0, best_delays[j][t+1] - t60);
        }
    }
    rep(t,best_answer.size()){
        best_overs[t+1] += best_overs[t];
    }

    auto& current_answer = best_answer;
    auto& current_delays = best_delays;
    auto& current_overs = best_overs;
    auto& P = current_answer;
    int g = 0;
    vector<int> probs{OPT_PROB_POINT_SWAP, OPT_PROB_POINT_INSERT, OPT_PROB_ADJACENT_SWAP};
    while(timer.ms() < CHUKAN_TIME_LIMIT){
        // 山登り
        Opt_Kinbo kinbo = OPT_POINT_SWAP;
        const int rand = xorshift()%100;
        {
            int sum = 0;
            rep(i,probs.size()){
                sum += probs[i];
                if(rand < sum){
                    kinbo = Opt_Kinbo(i);
                    break;
                }
            }
        }
        switch(kinbo){
        case OPT_POINT_SWAP:{
            int p1 = xorshift() % min(static_cast<int>(P.size()), 999);
            const int len = P.size() / 2;
            const int l = max(0, p1 - len);
            //1000なら最後のやつは固定
            //1000未満なら最後のやつも動かす
            const int r = min(min(static_cast<int>(P.size()), 999), p1 + len);
            int p2 = xorshift()%(r-l) + l;
            if(p1 == p2) continue;
            if(P[p1] == P[p2]) continue;
            if(p1 > p2){
                swap(p1,p2);
            }
            const int before_over = current_overs[p2+1] - current_overs[p1];
            if(before_over == 0) continue;
            g++;
            const int before_total_over = current_overs.back() - current_overs[p1];
            swap(P[p1], P[p2]);

            int after_over = 0;
            bool ok = true;
            vector<int> chukan_delays(M);
            rep(j,M){
                int delay = current_delays[j][p1];
                for(int t = p1; t <= p2; ++t){
                    after_over += max(0, delay + T_tenchi[j][P[t]] - max_delay[j]);
                    delay = min(max_delay[j], delay + T_tenchi[j][P[t]]);
                    if(can_complete && j == M-1 && t+1 == P.size()){
                        after_over += delay;
                    }
                    delay = max(0, delay - t60);
                }
                if(after_over >= before_over){
                    ok = false;
                    break;
                }
                chukan_delays[j] = delay;
            }
            if(!ok){
                swap(P[p1], P[p2]);
                continue;
            }
            if(p2 + 1 < current_delays.front().size()){
                rep(j,M){
                    int delay = chukan_delays[j];
                    for(int t = p2+1; t < P.size(); ++t){
                        after_over += max(0, delay + T_tenchi[j][P[t]] - max_delay[j]);
                        delay = min(max_delay[j], delay + T_tenchi[j][P[t]]);
                        if(can_complete && j == M-1 && t+1 == P.size()){
                            after_over += delay;
                        }
                        delay = max(0, delay - t60);
                    }
                    if(after_over >= before_total_over){
                        ok = false;
                        break;
                    }
                    if(!ok) break;
                }
            }
            if(!ok){
                swap(P[p1], P[p2]);
                continue;
            }
            if(after_over < before_total_over || (after_over == before_total_over && xorshift()%NO_CHANGE_UPDATE_BUNBO < NO_CHANGE_UPDATE_BUNSHI)){
                for(int t = p1; t < P.size(); ++t){
                    current_overs[t+1] = 0;
                }
                rep(j,M){
                    for(int t = p1; t < P.size(); ++t){
                        assert(P[t] != -1);
                        current_overs[t+1] += max(0, current_delays[j][t] + T_tenchi[j][P[t]] - max_delay[j]);
                        current_delays[j][t+1] = min(max_delay[j], current_delays[j][t] + T_tenchi[j][P[t]]);
                        if(can_complete && j == M-1 && t+1 == P.size()){
                            current_overs[t+1] += current_delays[j][t+1];
                        }
                        current_delays[j][t+1] = max(0, current_delays[j][t+1] - t60);
                    }
                }
                for(int t = p1; t < P.size(); ++t){
                    current_overs[t+1] += current_overs[t];
                }
                // cerr<<g<<" "<<current_overs.back()<<endl;
            }else{
                swap(P[p1], P[p2]);
                continue;
            }
            break;
        }case OPT_POINT_INSERT:{
            int from = xorshift()%min(static_cast<int>(P.size()), 999);
            const int len = xorshift()%P.size() / 2 + 1;
            const int l = max(0, from - len);
            const int r = min(static_cast<int>(P.size()), from + len);
            int to = xorshift()%(r-l) + l;
            if(from == to) continue;
            int p1, p2;
            if(from < to){
                p1 = from;
                p2 = to-1;
            }else{
                p1 = to;
                p2 = from;
            }
            const int before_over = current_overs[p2+1] - current_overs[p1];
            if(before_over == 0) continue;
            g++;
            const int before_total_over = current_overs.back() - current_overs[p1];
            if(from < to){
                for(int i = from; i < to; i++){
                    swap(P[i], P[i+1]);
                }
            }else{
                for(int i = from; i > to; i--){
                    swap(P[i], P[i-1]);
                }
            }

            int after_over = 0;
            bool ok = true;
            vector<int> chukan_delays(M);
            rep(j,M){
                int delay = current_delays[j][p1];
                for(int t = p1; t <= p2; ++t){
                    after_over += max(0, delay + T_tenchi[j][P[t]] - max_delay[j]);
                    delay = min(max_delay[j], delay + T_tenchi[j][P[t]]);
                    if(can_complete && j == M-1 && t+1 == P.size()){
                        after_over += delay;
                    }
                    delay = max(0, delay - t60);
                }
                if(after_over >= before_over){
                    ok = false;
                    break;
                }
                chukan_delays[j] = delay;
            }
            if(!ok){
                swap(from,to);
                if(from < to){
                    for(int i = from; i < to; i++){
                        swap(P[i], P[i+1]);
                    }
                }else{
                    for(int i = from; i > to; i--){
                        swap(P[i], P[i-1]);
                    }
                }
                continue;
            }
            if(p2 + 1 < current_delays.front().size()){
                rep(j,M){
                    int delay = chukan_delays[j];
                    for(int t = p2+1; t < P.size(); ++t){
                        after_over += max(0, delay + T_tenchi[j][P[t]] - max_delay[j]);
                        delay = min(max_delay[j], delay + T_tenchi[j][P[t]]);
                        if(can_complete && j == M-1 && t+1 == P.size()){
                            after_over += delay;
                        }
                        delay = max(0, delay - t60);
                    }
                    if(after_over >= before_total_over){
                        ok = false;
                        break;
                    }
                    if(!ok) break;
                }
            }
            if(!ok){
                swap(from,to);
                if(from < to){
                    for(int i = from; i < to; i++){
                        swap(P[i], P[i+1]);
                    }
                }else{
                    for(int i = from; i > to; i--){
                        swap(P[i], P[i-1]);
                    }
                }
                continue;
            }
            if(after_over < before_total_over || (after_over == before_total_over && xorshift()%NO_CHANGE_UPDATE_BUNBO < NO_CHANGE_UPDATE_BUNSHI)){
                for(int t = p1; t < P.size(); ++t){
                    current_overs[t+1] = 0;
                }
                rep(j,M){
                    for(int t = p1; t < P.size(); ++t){
                        assert(P[t] != -1);
                        current_overs[t+1] += max(0, current_delays[j][t] + T_tenchi[j][P[t]] - max_delay[j]);
                        current_delays[j][t+1] = min(max_delay[j], current_delays[j][t] + T_tenchi[j][P[t]]);
                        if(can_complete && j == M-1 && t+1 == P.size()){
                            current_overs[t+1] += current_delays[j][t+1];
                        }
                        current_delays[j][t+1] = max(0, current_delays[j][t+1] - t60);
                    }
                }
                for(int t = p1; t < P.size(); ++t){
                    current_overs[t+1] += current_overs[t];
                }
                // cerr<<g<<" "<<current_overs.back()<<endl;
            }else{
                swap(from,to);
                if(from < to){
                    for(int i = from; i < to; i++){
                        swap(P[i], P[i+1]);
                    }
                }else{
                    for(int i = from; i > to; i--){
                        swap(P[i], P[i-1]);
                    }
                }
                continue;
            }
            break;
        }case OPT_ADJACENT_SWAP:{
            break;
        }
        }
    }

    // best_answer = current_answer;
    // cerr<<"opt_g:"<<g<<endl;
    // cerr<<"***B sum_overs:"<<current_overs.back() - (can_complete ? T[best_answer.back()][M-1] : 0)<<" ***"<<endl;
    return current_answer;
}

void solve(){
    Simulator sim;
    int g = 0;
    vector<int> best_answer;
    int best_eval = 0;
    int best_delay_sum = INF;

    vector<int> weights(M, WEIGHT_SMALL);
    int best_gamma = 0;
    for(int gamma = GAMMA_SMALL; gamma <= GAMMA_LARGE; gamma = gamma * gamma_delta + 1){
        g++;

        vector<int> P = greedy(weights, gamma);

        const int eval = challenge(sim, P);
        if(eval >= best_eval){
            best_gamma = gamma;
            best_answer = P;
            best_eval = eval;
            best_delay_sum = sim.delay_sum;
        }
        // cerr<<eval<<" gamma:"<<gamma<<endl;
    }

    int best_wi = -1;
    {
        const int gamma = best_gamma;
        for(int i = 0; i < M && timer.ms() < TIME_LIMIT; i++){
            weights[i] = WEIGHT_LARGE;
                g++;

            vector<int> P = greedy(weights, gamma);
            const int eval = challenge(sim, P);
            if(eval >= best_eval){
                best_wi = i;
                best_answer = P;
                best_eval = eval;
                best_delay_sum = sim.delay_sum;
            }
            weights[i] = WEIGHT_SMALL;
        }
    }
    if(best_wi != -1) weights[best_wi] = WEIGHT_LARGE;
    {
        vector<int> P = greedy_detail(weights, best_gamma);
        const int eval = challenge(sim, P);
        if(eval > best_eval){
            best_eval = eval;
            best_answer = P;
            best_delay_sum = sim.delay_sum;
        }
    }

    // cerr<<"***A sum_overs:"<<best_delay_sum<<" ***"<<endl;
    // cerr<<timer.ms()<<"[ms]"<<endl;

    if(best_eval >= 1e6 || best_delay_sum < OPT_KIJUN){
        auto P = yamanobori_opt(sim, best_eval, best_answer);
        const int eval = challenge(sim, P);
        if(eval > best_eval){
            best_answer = P;
            best_eval = eval;
        }
        // cerr<<timer.ms()<<"[ms]"<<endl;
    }
    best_eval = yamanobori(sim, best_answer);
    best_eval = brush_up(sim, best_answer);

    print_P(cout, best_answer);
    // cerr<<timer.ms()<<"[ms]"<<endl;
    assert(timer.ms() < 1990);
    // cerr<<"g:"<<g<<endl;
}

int main(int argc, char* argv[]){
    fast_io;

    if(argc >= 2){
        // OPT_PROB_POINT_SWAP = stoi(argv[1]);
        // OPT_PROB_POINT_INSERT = 100 - OPT_PROB_POINT_SWAP;

        // WEIGHT_LARGE = stoi(argv[1]);
        // ALPHA = stoi(argv[2]);
        // // WEIGHT_LARGE = 41;
        // // ALPHA = 60;
        // vector<int*> vec{
        //     &PROB_POINT_KOTAI,
        //     &PROB_RANGE_SWAP,
        //     &PROB_POINT_SWAP,
        //     &PROB_POINT_INSERT,
        //     &PROB_RANGE_INSERT,
        //     &PROB_ADJACENT_SWAP
        // };
        // int sum = 0;
        // rep(i,vec.size()){
        //     *(vec[i]) = stoi(argv[3+i]);
        //     sum += *vec[i];
        // }
        // rep(i,vec.size()){
        //     (*vec[i]) *= 100;
        //     (*vec[i]) /= sum;
        // }
        // // KEISHA = 3;
        // // CHUKAN_TIME_LIMIT = 1151;
        // // OPT_KIJUN = 60;
        // KEISHA = stoi(argv[9]);
        // CHUKAN_TIME_LIMIT = stoi(argv[10]);
        // OPT_KIJUN = stoi(argv[11]);
        // SUCCESS_BONUS = stoi(argv[1]);
        // YUGU_DELAY_T = stoi(argv[2]);
        // LEN_RANGE_SWAP = stoi(argv[1]);
        // LEN_RANGE_INSERT = stoi(argv[2]);
        // double prob = stod(argv[3]);
        // NO_CHANGE_UPDATE_BUNSHI = min(NO_CHANGE_UPDATE_BUNBO, max(0, (int)(prob * 1000)));
        // NO_CHANGE_UPDATE_BUNSHI = stoi(argv[1]);
    }else{
        // WEIGHT_LARGE = 280;
        // ALPHA = 156;
        // vector<int*> vec{
        //     &PROB_POINT_KOTAI,
        //     &PROB_RANGE_SWAP,
        //     &PROB_POINT_SWAP,
        //     &PROB_POINT_INSERT,
        //     &PROB_RANGE_INSERT,
        //     &PROB_ADJACENT_SWAP
        // };
        // int sum = 0;
        // vector<int> inp_vec{
        //     12,7,84,8,51,82
        // };
        // rep(i,vec.size()){
        //     *(vec[i]) = inp_vec[i];
        //     sum += *vec[i];
        // }
        // rep(i,vec.size()){
        //     (*vec[i]) *= 100;
        //     (*vec[i]) /= sum;
        //     cerr<<*vec[i]<<endl;
        // }
        // KEISHA = 47;
        // CHUKAN_TIME_LIMIT = 1354;
        // OPT_KIJUN = 38;
    }
    input();
    solve();
    return 0;
}

Submission Info

Compile Error

./Main.cpp: In constructor ‘Simulator::Simulator()’:
./Main.cpp:153:25: warning: ‘Simulator::will_stopes’ will be initialized after [-Wreorder]
  153 |     vector<vector<Pii>> will_stopes; //{pi, time}
      |                         ^~~~~~~~~~~
./Main.cpp:151:17: warning:   ‘std::vector<int> Simulator::delay’ [-Wreorder]
  151 |     vector<int> delay;
      |                 ^~~~~
./Main.cpp:171:5: warning:   when initialized here [-Wreorder]
  171 |     Simulator()
      |     ^~~~~~~~~
./Main.cpp:152:17: warning: ‘Simulator::ruiseki_chokines’ will be initialized after [-Wreorder]
  152 |     vector<int> ruiseki_chokines;
      |                 ^~~~~~~~~~~~~~~~
./Main.cpp:149:18: warning:   ‘std::bitset<1000> Simulator::feedback_done_delay’ [-Wreorder]
  149 |     bitset<1000> feedback_done_delay;
      |                  ^~~~~~~~~~~~~~~~~~~
./Main.cpp:171:5: warning:   when initialized here [-Wreorder]
  171 |     Simulator()
      |     ^~~~~~~~~
./Main.cpp: In member function ‘bool Simulator::operator()(int, bool)’:
./Main.cpp:257:21: warning: comparison of integer expressions of different signedness: ‘int’ and ‘std::vector<Simulator::Event>::size_type’ {aka ‘long unsigned int’} [-Wsign-compare]
  257 |             next_ei < event_order.size() && (event_order[next_ei].human_id != 0 || !event_order[next_ei].is_start);
      |             ~~~~~~~~^~~~~~~~~~~~~~~~~~~~
./Main.cpp:339:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘std::vector<Simulator::Event>::size_type’ {aka ‘long unsigned int’} [-Wsign-compare]
  339 |         if(next_ei >= event_order.size() || get_current_time() > max_T){
      |            ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~
./Main.cpp: In member function ‘int Simulator::get_current_time() const’:
./Main.cpp:351:20: warning: comparison of integer expressions of different signedness: ‘const int’ and ‘std::vector<Simulator::Event>::size_type’ {aka ‘long unsigned int’} [-Wsign-compare]
  351 |       ...

Judge Result