*it's just memoization, right?!)*, but ultimately feared for lack of real-world experience solving such problems. I read today a superb explanation of a principled approach to solving dynamic programming problems. Here it is:

- Try to define the problem at hand in terms of composable sub-problems. In other words, ask yourself what information would make solving this problem easier?
- Define a more rigorous recurrence relation between the sub-problems and the current problem. What are the base-cases and how do the sub-problems answer the current problem?
- Build a solution look up table (up to the point of the current problem) by first initializing it for the base cases and then for the sub-problems in a bottom-up approach. The bottom-up approach is the defining characteristic of a dynamic programming solution. Alone, the look up table is just memoization.
*Note*: building the solution table bottom up will often look like a post-order depth-first search.

Here is an implementation (in Scala) to the following problem:

Given a general monetary system with M different coins of value {c1, c2, . . . , cM}, devise an algorithm that can make change for amount N using a minimum number of coins. What is the complexity of your algorithm?

## No comments:

## Post a Comment