import numpy as np

def solution(times, times_limit):
    best_times = get_best_times(times)
    best_plan = get_best_plan(best_times, times_limit)
    return best_plan

def get_best_times(times):
    t = np.array(times)
    spots = len(times)
    bunny_count = spots-2
    best_times = np.reshape(t, (spots, 1, spots))
    one_step = np.reshape(t.T, (1, spots, spots))
    infinite_time = False
    while not infinite_time:
        temp = np.reshape(np.amin(best_times + one_step, axis=2), (spots, 1, spots))
        new_best_times = np.minimum(best_times, temp)
        if np.array_equal(best_times, new_best_times):
            best_times = new_best_times
            break;
        best_times = new_best_times
        for i in range(spots):
            if best_times[i][0][i] < 0:
                infinite_time = True
                break;
    if infinite_time:
        return list(range(bunny_count))
    best_times = np.reshape(best_times, t.shape)
    return best_times

def get_best_plan(best_times, times_limit):
    best_plan = []
    last_position = 0
    bulkhead = len(best_times)-1
    bunny_count = len(best_times)-2
    for plan in get_plans(bunny_count):
        estimated_time = 0
        for bunny_id in plan:
            next_position = bunny_id+1
            estimated_time += best_times[last_position][next_position]
            last_position = next_position
        estimated_time += best_times[last_position][bulkhead]
        if estimated_time <= times_limit:
            best_plan = get_better_plan(best_plan, plan)
    return best_plan

# TODO: implement get_plans
def get_plans(bunny_count):
    return [[1], [0], [1, 2], [0, 1, 2], [0, 1]]

def get_better_plan(a, b):
    if len(a) > len(b):
        return a
    if len(a) < len(b):
        return b
    if a == b:
        return a
    for i in range(len(a)):
        if a[i] == b[i]:
            continue
        if a[i] < b[i]:
            return a
        if a[i] > b[i]:
            return b
    return a

tests = [
        [[[0, 2, 2, 2, -1], [9, 0, 2, 2, -1], [9, 3, 0, 2, -1], [9, 3, 2, 0, -1], [9, 3, 2, 2, 0]], 1, [1, 2]],
        [[[0, 1, 1, 1, 1], [1, 0, 1, 1, 1], [1, 1, 0, 1, 1], [1, 1, 1, 0, 1], [1, 1, 1, 1, 0]], 3, [0, 1]],
        [[[0, 2, 2, 2, -1], [9, 0, 2, 2, -1], [9, 3, 0, 2, -1], [9, 3, 2, 0, -1], [9, 3, 2, 2, 0]], -1, []],
        [[[0, 2, 2, 2, -1], [9, 0, 2, 2, -1], [9, 3, 0, 2, -1], [9, 3, 2, 0, -1], [9, 3, 2, 2, 0]], 0, [1]],
        [[[0, 2, 2, 2, -1], [9, 0, 2, 2, -1], [9, 3, 0, 2, -1], [9, 3, 2, 0, -1], [9, 3, 2, 2, 0]], 2, [0, 1]],
        [[[0, 2, 2, 2, -1], [9, 0, 2, 2, -1], [9, 3, 0, 2, -1], [9, 3, 2, 0, -1], [9, 3, 2, 2, 0]], 3, [0, 1, 2]],
        ]

for test in tests:
    result = solution(test[0], test[1])
    print (test[0], test[1], result == test[2], result, test[2])