Dynamic programming

Dynamic programming is an algorithm technique, which is applicable to a problem which is
composed of overlapping sub-problems and the problem has Optimal sub-structure.
A problem is said to have overlapping sub-problems if a problem can be broken down into a sub-
problems which are reused several times or recursive algorithm solves same sub-problem over
and over.
So, this overlapping nature of the sub-problems help reducing the complexity by using a technique
called memoization.
emoi!ation is technique in which the result of a sub-problem is stored in a data structure if it
is computed for the 1st time. And next time if the same sub-problem is used, we lookup into the
data structure before solving the sub-poroblem.
So the output of any sub-problem is re-used to solve the other sub-problem.
As a result, the computation of overlapping part in sub-problems is done only once. "hereby
reducing the complexity.
Optimal Substructure-
A problem is said to have optimal sub-structure if an optimal solution for the problem can be
constructed efficiently from optimal solutions of its sub-problems.
• Solution to a sub-problem is obtained by using the result of previously computed sub-
• !ll sub-problems are computed using previously computed sub-problems e"cept the
base cases, which we find to derive before start solving the sub-problems.
• So we consider base cases as previosuly computed sub-problems for solving other sub-
#.g- fibonaci series
#n fibonacci series, the base case is the following$-
• %e consider Solution for fibonacci of & '(
• %e consider Solution for fibonacci of ( '(
)ow, we use these base cases to get solution to other sub-problems.
Difference between dynamic programming and divide $ con%uer
Divide and con%uer -
Divides the problem into sub-problems.
Solves the sub-problems.
*ombine the result of sub-problems to get the solution to original problem.
&ote- 'n Divide $ (on%uer the sub-problems are independent of each other.+whereas in D,
sub-problems are overlapping in nature means solution to one sub-problem may be dependent on
the output of other sub-problem for computation-.
)ey 'dea behind dynamic programming
• In general, to solve a given problem, we need to solve diferent parts of the problem
(subproblems), then combine the solutions of the subproblems to reach an overall
• Often, many of these subproblems are really the same.
• The dynamic programming approach seeks to solve each subproblem only once, thus
reducing the number of computations once the solution to a given subproblem has been
computed, it is stored or !memo"i#ed! the ne$t time the same solution is needed, it is
simply looked up.
• This approach is especially useful when the number of repeating subproblems grows
e$ponentially as a function of the si#e of the input.
Top-Down Approach
Problem Solving Help:- %ain task of solving a problem using dp is "
• &reaking down the problem into sub"problems.
• 'inding out the base cases and recurrence relation(re"occurring relation which tells how
one sub"problem uses other sub"problem).
Sub-,roblem (
Sub-*roblem +
Sub-,roblem . Sub-,roblem n
Sub-,roblem ( will
act as the base case for
Solving rest of the sub
,roblems. #t is memoi!ed
Sub-,roblem (
)ew Sub-,roblem
*omposed of
/ere Sub-,roblem (
is not recalculated
instead it looks up in
the data structure used
for memoi!ation
"his sub-problem will be
solved as it is a
new sub-problem.
"his sub-problem will be
a part of further
And there it will not
be recomputed.
*omputation of each sub-problem is done only
Types of dynamic programming Approaches
1) Top-down Approach:- (emoi!a"ion Approach)
• In this approach, we solve the top sub"problems (rst which recurses down to solve the
sub"problems.(Overlapping sub"problems)
• The solution to the sub"problem is computed and stored in a table.
• )henever a new sub"problem is being solved, (rst we check whether the sub"problem is
already solved or not. If it is then we use the same result, otherwise we compute it*s result
and store it in the table.
• +ll ,ecursive alog*s uses memoi#ation are e$amples of top"down dynamic programming.
• It re-uires us to save all the previously computed results at any point in time.
• If the si#e of problem is large, then we will end up occupying large space for the previously
computed results which is not good.
• ,ecursion overhead will not be there.
• .ere any subproblem can be encountered any time so we need to store all the results till
end. $a!y approach(or on demand approach)
%&g:- solving 'bonacci series (sing rec(rsive algo and memoi!ing "he res(l"s a"
each s"age&
'b(n) ) 'b(n-1) * 'b(n-+) called rec(rsivly&
+) ,o""om -p Approach:- (dynamic programming)
• In this approach, we solve the sub"problems (rst in a particular order and then use their
solution to build the solution to the original problem/top problems.
• .ere also the solution to sub"problems is memoi#ed.
• Order of the solving sub"problems is of important interest as this order helps us in
memoi#ing the intermediate results only and throwing away the rest of the previously
computed results which are of no use(will not be used further).
• .ere since we are solving the sub"problems in a order, such that only the intermediate
results of sub"problems are re-uired to build the solution to original problem/top problems.
• It re-uires us to store only the intermediate results of sub"problems and throws away the
rest of the results of sub"problems.
• 0o recursion overhead
• 1pace re--uirement is not much.
.or solving s(b-problems/ 0rdering of s(b-problems is impor"an" &
%&g:- 'bonacci series (sing follwong rec(rrence rela"ion&
'b(n) ) 'b(n-1) * 'b(n-+) loopi" from + "o n