Seongbeom Park
84894a7e43
Verifying solution... Test 1 passed! Test 2 passed! Test 3 failed [Hidden] Test 4 passed! [Hidden] Test 5 failed [Hidden] Test 6 failed [Hidden] Test 7 failed [Hidden] Test 8 failed [Hidden] Test 9 failed [Hidden] Test 10 failed [Hidden]
79 lines
2.7 KiB
Python
79 lines
2.7 KiB
Python
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])
|