Train schedule

#include <iostream>
#include <vector>
#include <functional>
#include <set>
#include <algorithm>
#include <stack>
#include <unordered_map>
#include <map>
#include <iomanip>
#include <limits>
#include <queue>

std::tuple<int> readInt1(){
    int a;
    std::cin >> a;
    return {a};
}
std::tuple<int,int> readInt2(){
    int a, b;
    std::cin >> a >> b;
    return {a,b};
}
std::tuple<int,int,int> readInt3(){
    int a, b, c;
    std::cin >> a >> b >> c;
    return {a,b,c};
}

std::vector<int> readVecInt(int n){
    std::vector<int> arr(n);
    for (int i = 0; i < n; i++){
        int a;
        std::cin >> a;
        arr[i] = a;
    }
    return arr;
}
std::vector<std::string> readVecStr(int n){
    std::vector<std::string> arr(n);
    for (int i = 0; i < n; i++){
        std::string a;
        std::cin >> a;
        arr[i] = a;
    }
    return arr;
}

std::vector<long long> readVecLong(int n){
    std::vector<long long> arr(n);
    for (int i = 0; i < n; i++){
        long long a;
        std::cin >> a;
        arr[i] = a;
    }
    return arr;
}

std::vector<std::tuple<int,int>> readVecTup2(int n){
    std::vector<std::tuple<int,int>> arr(n);
    for (int i = 0; i < n; i++){
        int a, b;
        std::cin >> a;
        std::cin >> b;
        arr[i] = {a,b};
    }
    return arr;
}

std::vector<std::tuple<int,int,int>> readVecTup3(int n){
    std::vector<std::tuple<int,int,int>> arr(n);
    for (int i = 0; i < n; i++){
        int a, b, c;
        std::cin >> a;
        std::cin >> b;
        std::cin >> c;
        arr[i] = {a,b,c};
    }
    return arr;
}
std::vector<std::tuple<int,int,int,int>> readVecTup4(int n){
    std::vector<std::tuple<int,int,int,int>> arr(n);
    for (int i = 0; i < n; i++){
        int a, b, c,d;
        std::cin >> a;
        std::cin >> b;
        std::cin >> c;
        std::cin >> d;
        arr[i] = {a,b,c,d};
    }
    return arr;
}

void printNewLine(){std::cout << "\n";}
template<typename T, typename... Ts>
std::tuple<Ts...> tail(std::tuple<T,Ts...> as){
    return std::apply([](T &a, Ts... b){return std::make_tuple(b...);},as);
}

template<typename T>
void print(T a){std::cout << std::setprecision(19) << a;}
template<typename... T>
void println(T... a);

template<typename T, typename Ts>
void print(std::tuple<T,Ts> a){
    print(std::get<0>(a));
    print(" ");
    print(std::get<1>(a));
}

template<typename T, typename... Ts>
void print(std::tuple<T,Ts...> a){
    print(std::get<0>(a));
    print(" ");
    print(tail(a));
}



template<typename T>
void print(const std::vector<T> &arr, int width = -1){
    if (width == -1) width = arr.size();
    for (int i = 0; i < (int)arr.size(); i++){
        if ((i%width) == width-1 && i != (int)arr.size()-1){
            print(" ");
            println(arr[i]);
        }else if ((i%width) == 0){        
            print(arr[i]);
        }else {
            print(" ");
            print(arr[i]);
        }
    }    
}
template<typename... T>
void println(T... a){print(a...);printNewLine();}



void program(){
    auto arr = readVecLong(1);
    auto n = arr[0];
    std::stack<std::string> program;
    program.push("END");
    while (n > 4){
        if (n%2){
            n -= 3;
            program.push("ADD");
        } else{
            n /= 2;
            program.push("MUL");
        }
    }
    if (n==4) {
        n -= 3;
        program.push("ADD");
    };
    if (n==3) {
        n-=3;
    }
    if (n==2) {
        n/=2;
        program.push("MUL");
    }
    if (n==0){
        println(0);
    } else {
        println(program.size());
        while (!program.empty()){
            println(program.top());
            program.pop();
        }
    }
}
int main() {
    auto [n] = readInt1();
    auto arr = readVecInt(n);
    std::priority_queue<std::tuple<int,int>> queue;
    std::vector<int> list;
    int numBase = 0;
    for (int i = 0; i < n; i++){
        if (arr[i]==1) numBase +=1;
        if (arr[i]!=1) queue.push({-i,i});
        int num = numBase;        
        while (std::get<0>(queue.top()) == -i){
            num += 1;
            auto [v,idx] = queue.top();
            queue.pop();
            queue.push({-(i+arr[idx]),idx});
        }
        list.push_back(num);
    }
    println(list);
    return 0;
}

Test 1

Verdict: RUNTIME ERROR

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: RUNTIME ERROR

Test 7

Verdict: ACCEPTED

Test 8

Verdict: ACCEPTED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: ACCEPTED

Test 11

Verdict: ACCEPTED

Test 12

Verdict: ACCEPTED

Test 13

Verdict: RUNTIME ERROR

Test 14

Verdict: RUNTIME ERROR

Test 15

Verdict: ACCEPTED

Test 16

Verdict: RUNTIME ERROR

Test 17

Verdict: ACCEPTED

Test 18

Verdict: ACCEPTED

Test 19

Verdict: ACCEPTED

Test 20

Verdict: ACCEPTED

Test 21

Verdict: ACCEPTED

Test 22

Verdict: ACCEPTED

Test 23

Verdict: ACCEPTED

Test 24

Verdict: RUNTIME ERROR

Test 25

Verdict: ACCEPTED

Test 26

Verdict: RUNTIME ERROR

Test 27

Verdict: ACCEPTED

Test 28

Verdict: ACCEPTED

Test 29

Verdict: ACCEPTED

Test 30

Verdict: ACCEPTED

Test 31

Verdict: ACCEPTED

Test 32

Verdict: ACCEPTED

Test 33

Verdict: ACCEPTED

Test 34

Verdict: ACCEPTED

Test 35

Verdict: ACCEPTED

Test 36

Verdict: ACCEPTED

Test 37

Verdict: ACCEPTED

Test 38

Verdict: ACCEPTED

Test 39

Verdict: ACCEPTED

Test 40

Verdict: ACCEPTED

Test 41

Verdict: ACCEPTED

Test 42

Verdict: ACCEPTED

Test 43

Verdict: ACCEPTED

Test 44

Verdict: ACCEPTED

Test 45

Verdict: ACCEPTED

Test 46

Verdict: ACCEPTED

Test 47

Verdict: ACCEPTED

Test 48

Verdict: ACCEPTED

Test 49

Verdict: ACCEPTED

Test 50

Verdict: ACCEPTED

Test 51

Verdict: ACCEPTED

Test 52

Verdict: ACCEPTED

Test 53

Verdict: ACCEPTED

Test 54

Verdict: ACCEPTED

Test 55

Verdict: ACCEPTED

Test 56

Verdict: ACCEPTED

Test 57

Verdict: ACCEPTED

Test 58

Verdict: ACCEPTED

Test 59

Verdict: ACCEPTED

Test 60

Verdict: ACCEPTED

Test 61

Verdict: TIME LIMIT EXCEEDED

Test 62

Verdict: TIME LIMIT EXCEEDED

Test 63

Verdict: TIME LIMIT EXCEEDED

Test 64

Verdict: TIME LIMIT EXCEEDED

Test 65

Verdict: TIME LIMIT EXCEEDED

Test 66

Verdict: ACCEPTED

Test 67

Verdict: TIME LIMIT EXCEEDED

Test 68

Verdict: ACCEPTED

Test 69

Verdict: TIME LIMIT EXCEEDED

Test 70

Verdict: ACCEPTED

Test 71

Verdict: RUNTIME ERROR

Test 72

Verdict: RUNTIME ERROR