5 Answers
5

Memoization is a term describing an optimization technique where you cache previously computed results, and return the cached result when the same computation is needed again.

Dynamic programming is a technique for solving problems recursively and is applicable when the computations of the subproblems overlap.

Dynamic programming is typically implemented using tabulation, but can also be implemented using memoization. So as you can see, neither one is a "subset" of the other.

A reasonable follow-up question is: What is the difference between tabulation (the typical dynamic programming technique) and memoization?

When you solve a dynamic programming problem using tabulation you solve the problem "bottom up", i.e., by solving all related sub-problems first, typically by filling up an n-dimensional table. Based on the results in the table, the solution to the "top" / original problem is then computed.

If you use memoization to solve the problem you do it by maintaining a map of already solved sub problems. You do it "top down" in the sense that you solve the "top" problem first (which typically recurses down to solve the sub-problems).

A good slide from here (link is now dead, slide is still good though):

If all subproblems must be solved at least once, a bottom-up dynamic-programming algorithm usually outperforms a top-down memoized algorithm by a constant factor

No overhead for recursion and less overhead for maintaining table

There are some problems for which the regular pattern of table accesses in the dynamic-programming algorithm can be exploited to reduce the time or space requirements even further

If some subproblems in the subproblem space need not be solved at all, the memoized solution has the advantage of solving only those subproblems that are definitely required

Hi, your answer is wrong. See my answer for the correct response. Many comp sci students and professors have been incorrectly taught, so the mistake is understandable.
–
Tom MNov 1 '14 at 16:16

Dynamic programming is most often implemented by means of tabulation, so since the OP asked about the relation between dynamic programming and memoization, I interpreted it as tabulation vs memoization. Anyway, I have now clarified the answer.
–
aioobeNov 14 '14 at 14:26

Memoization is an easy method to track previously solved solutions (often implemented as a hash key value pair, as opposed to tabulation which is often based on arrays) so that they aren't recalculated when they are encountered again. It can be used in both both bottom up or top down methods.

So Dynamic programming is a method to solve certain classes of problems by solving recurrence relations/recursion and storing previously found solutions via either tabulation or memoization. Memoization is a method to keep track of solutions to previously solved problems and can be used with any function that has unique deterministic solutions for a given set of inputs.

"In computing, memoization is an optimization technique used primarily to speed up computer programs by having function calls avoid repeating the calculation of results for previously-processed inputs."

"In mathematics and computer science, dynamic programming is a method for solving complex problems by breaking them down into simpler subproblems."

When breaking a problem into smaller/simpler subproblems, we often encounter the same subproblem more then once - so we use Memoization to save results of previous calculations so we don't need to repeat them.

Dynamic programming often encounters situations where it makes sense to use memoization but You can use either technique without necessarily using the other.

Memoization is the top-down technique(start solving the given problem by breaking it down) and dynamic programming is a bottom-up technique(start solving from the trivial sub-problem, up towards the given problem)

DP finds the solution by starting from the base case(s) and works its way upwards.
DP solves all the sub-problems, because it does it bottom-up

Unlike Memoization, which solves only the needed sub-problems

DP has the potential to transform exponential-time brute-force solutions into polynomial-time algorithms.

DP may be much more efficient because its iterative

On the contrary, Memoization must pay for the (often significant) overhead due to recursion.

To be more simple,
Memoization uses the top-down approach to solve the problem i.e. it begin with core(main) problem then breaks it into sub-problems and solve these sub-problems similarly. In this approach same sub-problem can occur multiple times and consume more CPU cycle, hence increase the time complexity. Whereas in Dynamic programming same sub-problem will not be solved multiple times but the prior result will be used to optimize the solution.

(2) Memoization is DP with the risk of stack overflow is the recursion is deep. DP bottom up does not have this risk.

(3) Memoization needs a hash table. So additional space, and some lookup time.

So to answer the question:

-Conceptually, (1) means they are the same thing.

-Taking (2) into account, if you really want, memoization is a subset of DP, in a sense that a problem solvable by memoization will be solvable by DP, but a problem solvable by DP might not be solvable by memoization (because it might stack overflow).