I'd say that is a version of the Partitions of Integers problem where a special condition is imposed on the integers that we can use.

You can find and solve this problem on HackerRank, section Cracking the Coding Interview.

First thing, I have taken a non completely trivial example and I studied it on paper.

Given in input [2, 5, 3, 6] and 10, it easy to see how the solution is 5:

2 + 2 + 2 + 2 + 2 5 + 5 2 + 3 + 5 3 + 3 + 2 + 2 2 + 2 + 6The fact that it is marked as DP, should put me on the way of looking for a Dynamic Programming solution. So I create a table, reasoning how to fill it up coherently. Each column represents the totals I could get, ranging from 0 to the passed value. I have a column for each number passed in the input list, plus the topmost one, that represents the "no value" case.

Cell in position (0, 0) is set to 1, since I could get 0 from no value in just one way. The other values in the first row are set to zero, since I can't get that total having nothing to add up. We don't care much what it is in the other cells, since we are about to get the right value by construction.

We'll move in the usual way for a dynamic programming problem requiring a bidimensional table, row by row, skipping the zeroth one, from top to bottom, moving from left to right. We could have filled the first column before starting the procedure, since it is immediate to see that there is only one way to get a total of zero, whichever number I have at hand. Still, in this case it doesn't help to make the code simpler, so I just keep it in the normal table filling part.

For each cell what I have to do is:

- copy the value from the cell above
- if "cur", the current value associated to the row, is not greater than the current column index, add the value in the cell on the same row but "cur" times to the left

The second point refers to the contribution of the new element. I guess the picture will help understand it.

The arrow pointing down from (0, 0) to (1, 0) means that since having no values leads to have one way to get a sum of zero, this implies that having no value and 2 still gives at least one way to get a sum of zero.

The other arrow pointing down, from (2, 8) to (3, 8) means that having one way to get 8 from no value and [2, 5] implies we still have at least one way to get it from no value and [2, 5, 3].

The arrow pointing left from (1, 0) to (1, 2) means that since we have a way to get zero having a 2, if we add a 2, we have a way to get 2 as a total.

The arrow pointing left from (3, 5) to (3, 8) means that having two ways of getting 5 using [2, 5, 3] implies that we still have two way of getting 5 + 3 = 8. Added with the one coming from the cell above, it explains why we put 3 in this cell.

Following the algorithm, I have written this python code here below:

def solution_full(denominations, total): # 1 table = [[0] * (total + 1) for _ in range(len(denominations) + 1)] # 2 table[0][0] = 1 for i in range(1, len(denominations) + 1): # 3 for j in range(total+1): table[i][j] += table[i - 1][j] # 4 cur = denominations[i-1] if cur <= j: table[i][j] += table[i][j-cur] # 5 return table[-1][-1] # 61. In the example, denominations is [2, 5, 3, 6] and total is 10.

2. Table has total + 1 columns and a row for each denomination, plus one. Its values are all set to zero, but the left-topmost one, set to 1.

3. Loop on all the "real" cells, meaning that I skip just the first row. I move in the usual way. Left to right, from the upper row downward.

4. The current cell value is initialized copying the value from the immediate upper one.

5. If there are enough cell to the left, go get the value of the one found shifting for the value of the current denomination, and add it to the one calculated in the previous step.

6. Return the value in the bottom right cell, that represents our solution.

**How to save some memory**

Writing the code, I have seen how there is no use in keeping all the rows. The only point where I use the values in the rows above the current one is in (4), and there I use just the value in the cell immediately above the current one. So I refactored the solution in this way:

def solution(denominations, total): cache = [0] * (total + 1) # 1 cache[0] = 1 for denomination in denominations: # 2 for j in range(denomination, total+1): # 3 cache[j] += cache[j-denomination] return cache[-1]1. The memoization here is done just in one row. Initialized as in the previous version.

2. Since I don't care anymore of the row index, I can just work directly on the denominations.

3. Instead of checking explicitly for the column index, I can start the internal loop from the first good position.

I pushed my python script with both solutions and a slim test case to GitHub.

## No comments:

## Post a Comment