1

This assignment aims to implement a dynamic programming approach to a primitive calculator that can only add 1, multiply by 2 and multiply by 3. So with an input of n determine the minimum number of operations to reach n. I've implemented a very naive dp or what I think is a dp approach. It is not working. I have no-one else to ask. For an input of n = 5 the output of the below is: ([0, 1, 2, 2, 3, 4], [1, 1, 2, 3, 4, 5]) whereas there are two correct outputs for the list numbers = [1, 2, 4, 5] or [1, 3, 4, 5]. Some help would be greatly appreciated.

def DPmin_operations(n):

numbers = []
minNumOperations = [0]*(n+1)
numOps = 0
numbers.append(1)

for k in range(1,n+1):
    minNumOperations[k] = 10000

    # for *3 operator
    if k % 3 == 0:
        numOps = minNumOperations[k//3] + 1
        if numOps < minNumOperations[k]:
            minNumOperations[k] = numOps
            numbers.append(k)
    # for *2 operator
    elif k % 2 == 0:
        numOps = minNumOperations[k//2] + 1
        if numOps < minNumOperations[k]:
            minNumOperations[k] = numOps
            numbers.append(k)
    # for + 1 operator 
    elif k >= 1:
        numOps = minNumOperations[k - 1] + 1
        if numOps < minNumOperations[k]:
            minNumOperations[k] = numOps
            numbers.append(k)

return (minNumOperations, numbers)
Berwhale
  • 43
  • 1
  • 6
  • I would consider adding some comments to your code to make it easier to interpret what you're trying to do. Or at least explain your thinking behind why you created your code how you did. Would probably make it easier to see how you want to solve it. – TheBoro Jun 01 '16 at 07:10
  • check that: http://stackoverflow.com/a/36930764/1291716 – Sayakiss Jun 01 '16 at 08:06

1 Answers1

8

Note that the elif blocks should really be if blocks. Currently, you're using a greedy algorithm of always trying to divide by 3; if that fails, then trying to divide by 2; if that fails, then subtracting 1. It's possible that a number is divisible by 6 so that all three options are possible, and yet dividing by 2 is more optimal then dividing by 3.

As for getting your list of numbers, do that at the end. Store all possible parents, then work backwards from your goal to see how you got there.

def dp_min_ops(n):
    all_parents = [None] * (n + 1)
    all_min_ops = [0] + [None] * n

    for k in range(1, n + 1):
        curr_parent = k - 1
        curr_min_ops = all_min_ops[curr_parent] + 1

        if k % 3 == 0:
            parent = k // 3
            num_ops = all_min_ops[parent] + 1
            if num_ops < curr_min_ops:
                curr_parent, curr_min_ops = parent, num_ops

        if k % 2 == 0:
            parent = k // 2
            num_ops = all_min_ops[parent] + 1
            if num_ops < curr_min_ops:
                curr_parent, curr_min_ops = parent, num_ops

        all_parents[k], all_min_ops[k] = curr_parent, curr_min_ops

    numbers = []
    k = n
    while k > 0:
        numbers.append(k)
        k = all_parents[k]
    numbers.reverse()

    return all_min_ops, numbers

print(dp_min_ops(5))   # ([0, 1, 2, 2, 3, 4], [1, 3, 4, 5])
print(dp_min_ops(10))  # ([0, 1, 2, 2, 3, 4, 3, 4, 4, 3, 4], [1, 3, 9, 10])
Adriano
  • 1,697
  • 24
  • 27
  • 1
    Thanks so much for your answer. I'm having quite the difficulty understanding DP. – Berwhale Jun 01 '16 at 11:24
  • 1
    This works like a charm, but I still have a really hard time understanding exactly how it works. Quite mind bending. – DaniG2k Aug 09 '16 at 19:37