Из-за чего может быть runtime error? Задача "Автобус" с acmp

#include <iostream>
 
int main()
{
    short N;
    int M, S, min; double mint;
    std::cin >> N >> M;
    min = M;
    int **arr = new int*[N];
    for (int sr = 0; sr < N; sr++)
    {
        arr[sr] = new int[3];
    }
    for (int sr = 0; sr < N; sr++)
    {
        for (int sl = 0; sl < 3; sl++)
        {
            std::cin >> arr[sr][sl];
        }
        if (min > arr[sr][1])
        {
            min = arr[sr][1];
        }
    }
    int b = M - min;
    double *arrt = new double[b + 1];
    short k = 0;
    for (int i = min; i <= M; i++)
    {
        arrt[k] = 0;
        for (int sr = 0; sr < N; sr++)
        {
            if (i != 0)
            {
                arrt[k] += (double)arr[sr][0] / (double)i;
            }
            if (i > arr[sr][1])
            {
                arrt[k] += (double)arr[sr][2];
            }
        }
        k++;
    }
    mint = arrt[0];
    for (int g = 0; g <= b; g++)
    {
        if (mint >= arrt[g])
        {
            mint = arrt[g];
            S = g;
        }
    }
    S += min;
    if (S >= 0)
    {
        std::cout << S;
    }
    else
    {
        std::cout << "0";
    }
    delete[] arrt;
    for (int sr = 0; sr < N; sr++)
    {
        delete[] arr[sr];
    }
    delete[] arr;
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#define min(x, y) ((x)<(y)?(x):(y))
#define NMAX 1001
int N, M;
struct way {
    int limit;
    int dist;
    int hold;
}wp[NMAX];
int totalD=0;
int last_broken_law;
void skip_similar_laws()
{
    while (last_broken_law + 1 < N &&
        wp[last_broken_law].limit == wp[last_broken_law + 1].limit)
        ++last_broken_law;
}
int faster(const void * a, const void * b)
{
    return (((way*)a)->limit - ((way*)b)->limit);//from the slowest to the fastest a-b
}
int main() {
    freopen("INPUT.TXT", "r", stdin);
    freopen("OUTPUT.TXT", "w", stdout);
    scanf("%d%d", &N, &M);//std::cin>>N>>M
    for (int i = 0; i < N; ++i)
    {
        scanf("%d%d%d", &wp[i].dist, &wp[i].limit, &wp[i].hold);
        totalD += wp[i].dist;
    }
    qsort(wp, N, sizeof(struct way), faster);
    int selected = min(wp[0].limit, M);
    ////algorithm initialization
    double min_time = 1.0*totalD/selected;
    int best_speed = selected;
    int fines = 0;
    //no laws were broken before
    last_broken_law = 0;
    int it = 0;
    while(last_broken_law<N)//from the slowest to the fastest
    {
        skip_similar_laws();//try braking another law
        if (wp[last_broken_law].limit > M)
            break;
        //pay all fines for this breaking
        while (it <= last_broken_law)
            fines += wp[it++].hold;
        //from here and onwards it is the last nonbroken law. 
        //let's try to run at its speedlimit
        selected = M;
        if (it < N && wp[it].limit<M)
            selected = wp[it].limit;//selected=min(M, speedlimit)
 
        double time= 1.0*totalD/selected+fines;//t=S/v +fines
        if (time < min_time) {
            best_speed = selected;
            min_time = time;
        }
        last_broken_law = it;
    }
    printf("%d", best_speed);
    return 0;
}

        if (wp[last_broken_law].limit > M)
            break;
        //pay all fines for this breaking
        while (it <= last_broken_law)
            fines += wp[it++].hold;