Finding minimum sum of non consecutive elements - python-3.x

Question

I'm trying to find the minimum sum of non consecutive elements in list,
where every time I can jump one cell or two cells.
The first cell is not counted in sum.
The implementation has to include recursion and memoization. I tried to implement such method, but unfortunately, it doesn't actually use memoization and it doesn't work for some examples.
My code looks like this:
def optimal_cruise_seasick(toilet_prices):
prices_dict = {}
return optimal_cruise_seasick_mem(toilet_prices, 0, len(toilet_prices), prices_dict)
def optimal_cruise_seasick_mem(prices_lst, start, end, dic):
if (start,end) in dic:
return dic[(start,end)]
if(start + 1 == end or start + 2 == end):
return prices_lst[end-1]
min_cost = prices_lst[end-1]
i = start + 1
while(i < end - 1):
one = optimal_cruise_seasick_mem(prices_lst, i, i+1, dic)
two = optimal_cruise_seasick_mem(prices_lst, i, i+2, dic)
if (one <= two):
min_cost += one
i += 1
else:
min_cost += two
i += 2
dic[(start,end)] = min_cost
return min_cost
I tried to run it for toilet_prices = [20,40,60,80,100,70,50,30,10,30].
It returns 320 instead of 250 (40,80,70,30,30). How should I fix my code so it will work as required?
Thanks!

Answer 1

Your implementation is, frankly, confusing. I have written an alternate implementation that works correctly (per your clarifications in the comments), though I don't know if it's memoizing in the way you want it to.
What we do is start at the first "actual" thing in the prices list (stripping off the first element; in your example, 20), and then successively see whether chopping off the left one or left two elements gives us a lower sum.
def f(prices, memo):
if prices not in memo:
if len(prices) == 1:
memo[prices] = prices[0]
elif len(prices) == 2:
# We must include the final cell in the list, but can choose to get there
# either by two 1-moves or one 2-move. Obviously the one 2-move is going
# to be non-pessimal if all prices are non-negative, but we'll put the min
# call in here for elucidation/explicitness anyway.
memo[prices] = min(prices[1], prices[0] + prices[1])
else:
memo[prices] = prices[0] + min(f(prices[1:], memo), f(prices[2:], memo))
return memo[prices]
def optimal_cruise_seasick(prices):
return f(prices[1:], dict())
Adding some print statements to indicate when we read from memo:
>>> optimal_cruise_seasick((20,40,60,80,100,70,50,30,10,30))
Read from memo: (10, 30) -> 30
Read from memo: (30, 10, 30) -> 60
Read from memo: (50, 30, 10, 30) -> 80
Read from memo: (70, 50, 30, 10, 30) -> 130
Read from memo: (100, 70, 50, 30, 10, 30) -> 180
Read from memo: (80, 100, 70, 50, 30, 10, 30) -> 210
250
As you can see, it's memoizing over suffixes of the prices list.
I should add that you can achieve the same effect in a cleaner way using functools.lru_cache. The f2 here is equivalent to the f above (if your price lists are short enough that everything fits into the cache), except that you don't pass in a dict() for memo, obviously.
from functools import lru_cache
#lru_cache()
def f2(prices):
if len(prices) == 1:
return prices[0]
elif len(prices) == 2:
return min(prices[1], prices[0] + prices[1])
else:
return prices[0] + min(f2(prices[1:]), f2(prices[2:]))