Recursive algorithm using memoization

Question

My problem is as follows: I have a list of missions each taking a specific amount of time and grants specific amount of points, and a time 'k' given to perform them:

e.g: missions = [(14,3),(54,5),(5,4)] and time = 15

in this example I have 3 missions and the first one gives me 14 points and takes 3 minutes. I have 15 minutes total. Each mission is a tuple with the first value being num of points for this mission and second value being num of minutes needed to perform this mission.

I have to find recursively using memoization the maximum amount of points I am able to get for a given list of missions and given time.

I am trying to implement a function called choose(missions,time) that will operate recursively and use the function choose_mem(missions,time,mem,k) to achive my goal. the function choose_mem should get 'k' which is the number of missions to choose from, and mem which is an empty dictionary, mem, which will contain all the problems that were already been solved before.

This is what I got so far, I need help implementing what is required above, I mean the dictionary usage (which is currently just there and empty all the time), and also the fact that my choose_mem function input is i,j,missions,d and it should be choose_mem(missions, time, mem, k) where mem = d and k is the number of missions to choose from.

If anyone can help me adjust my code it would be very appreciated.

mem = {}

def choose(missions, time):
    j = time
    result = []
    for i in range(len(missions), 0, -1):
        if choose_mem(missions, j, mem, i) != choose_mem(missions, j, mem, i-1):
            j -= missions[i - 1][1]
    return choose_mem(missions, time, mem, len(missions)) 

def choose_mem(missions, time, mem, k): 
    if k == 0: return 0
    points, a = missions[k - 1]
    if a > time:
        return choose_mem(missions, time, mem, k-1) 
    else:
        return max(choose_mem(missions, time, mem, k-1),
                   choose_mem(missions, time-a, mem, k-1) + points)

You are correct and I actually wrote it above the code if you notice. It is one of the things I need help introducing my code with. — Matthew D
– Matthew D, Commented May 10, 2013 at 10:35
It has helped. I altered my code a bit so I think it's more understandable right now. I have all my stuff in place. The only thing I have to do now is the check if 'mem' = my dictionary, contains the answer im looking for. I really struggled with that and I couldnt find a way to add the dictionary to my code which would make sense. Could you give me a final helping hand so I could finish this program? — Matthew D
– Matthew D, Commented May 10, 2013 at 11:38

pcalcao · Accepted Answer · 2013-05-10 14:38:37Z

4

This is a bit vague, but your problem is roughly translated to a very famous NP-complete problem, the Knapsack Problem.

You can read a bit more about it on wikipedia, if you replace weight with time, you have your problem.

Dynamic programming is a common way to approach that problem, as you can see here: http://en.wikipedia.org/wiki/Knapsack_problem#Dynamic_programming

Memoization is more or less equivalent to Dynamic Programming, for pratical matters, so don't let the fancy name fool you.

The base concept is that you use an additional data structure to store parts of your problem that you already solved. Since the solution you're implementing is recursive, many sub-problems will overlap, and memoization allows you to only calculate each of them once.

So, the hard part is for you to think about your problem, what what you need to store in the dictionary, so that when you call choose_mem with values that you already calculated, you simply retrieve them from the dictionary, instead of doing another recursive call.

If you want to check an implementation of the generic 0-1 Knapsack Problem (your case, since you can't add items partially), then this seemed to me like a good resource:

https://sites.google.com/site/mikescoderama/Home/0-1-knapsack-problem-in-p

It's well explained, and the code is readable enough. If you understand the usage of the matrix to store costs, then you'll have your problem worked out for you.

edited May 10, 2013 at 14:38

answered May 10, 2013 at 9:29

pcalcao

16k1 gold badge49 silver badges65 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Matthew D Over a year ago

Wow yea, I just checked the Knapsack Problem on wikipedia and it seems almost exact to mine (except there it's weight instead of time like you pointed out). Thanks for the help I will definitely try to use the information there to solve my problem.

Matthew D Over a year ago

If you can look at the new code I just edited it would be very much appreciated. The code actually works now, but I've been asked for specific type of function, meaning choose_mem should look like this: choose_mem(missions, time, mem, k) where mem is the 'd' dictionary and k is the num of missions left.

Collectives™ on Stack Overflow

Recursive algorithm using memoization

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related