Dynamic Programming - Primitive Calculator Python [duplicate]

问题

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)

回答1:

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])

来源：https://stackoverflow.com/questions/37561224/dynamic-programming-primitive-calculator-python

标签

python

dynamic-programming