{"id":31424,"date":"2019-03-20T10:00:14","date_gmt":"2019-03-20T14:00:14","guid":{"rendered":"https:\/\/simpleprogrammer.com\/?p=31424"},"modified":"2019-03-22T18:46:20","modified_gmt":"2019-03-22T22:46:20","slug":"guide-dynamic-programming","status":"publish","type":"post","link":"https:\/\/simpleprogrammer.com\/guide-dynamic-programming\/","title":{"rendered":"The Ultimate Guide to Dynamic Programming"},"content":{"rendered":"

\"\"Dynamic programming.<\/p>\n

Did you feel a little shiver when you read that?<\/p>\n

Imagine it again with those spooky Goosebumps letters.<\/p>\n

Dynamic programming.<\/strong><\/p>\n

When I talk to students of mine over at Byte by Byte<\/a>, nothing quite strikes fear into their hearts like dynamic programming.<\/p>\n

And I can totally understand why. Dynamic programming (DP) is as hard as it is counterintuitive. Most of us learn by looking for patterns among different problems. But with dynamic programming, it can be really hard to actually find the similarities.<\/p>\n

Even though the problems all use the same technique, they look completely different.<\/p>\n

However, there is a way to understand dynamic programming problems and solve them with ease. And in this post I\u2019m going to show you how to do just that.<\/p>\n

What Is Dynamic Programming?<\/h2>\n

Before we get into all the details of how to solve dynamic programming problems, it\u2019s key that we answer the most fundamental question:<\/p>\n

What is dynamic programming?<\/p>\n

Simply put, dynamic programming is an optimization technique that we can use to solve problems where the same work is being repeated over and over. You know how a web server may use caching? Dynamic programming is basically that.<\/p>\n

However, dynamic programming doesn\u2019t work for every problem. There are a lot of cases in which dynamic programming simply won\u2019t help us improve the runtime of a problem at all. If we aren\u2019t doing repeated work, then no amount of caching will make any difference.<\/p>\n

To determine whether we can optimize a problem using dynamic programming, we can look at both formal criteria of DP problems. I\u2019ll also give you a shortcut in a second that will make these problems much quicker to identify.<\/p>\n

Let\u2019s start with the formal definition.<\/p>\n

A problem can be optimized using dynamic programming if it:<\/p>\n

    \n
  1. has an optimal substructure.<\/li>\n
  2. has overlapping subproblems.<\/li>\n<\/ol>\n

    If a problem meets those two criteria, then we know for a fact that it can be optimized using dynamic programming.<\/p>\n

    Optimal Substructure<\/h3>\n

    Optimal substructure<\/a> is a core property not just of dynamic programming problems but also of recursion in general. If a problem can be solved recursively, chances are it has an optimal substructure.<\/p>\n

    Optimal substructure simply means that you can find the optimal solution to a problem by considering the optimal solution to its subproblems.<\/p>\n

    For example, if we are looking for the shortest path in a graph, knowing the partial path to the end (the bold squiggly line in the image below), we can compute the shortest path from the start to the end, without knowing any details about the squiggly path.<\/p>\n

    \"\"<\/p>\n

    What might be an example of a problem without optimal substructure?<\/p>\n

    Consider finding the cheapest flight between two airports. According to Wikipedia<\/a>:<\/p>\n

    \u201cUsing online flight search, we will frequently find that the cheapest flight from airport A to airport B involves a single connection through airport C, but the cheapest flight from airport A to airport C involves a connection through some other airport D.\u201d<\/p>\n

    While there is some nuance here, we can generally assume that any problem that we solve recursively will have an optimal substructure.<\/p>\n

    Overlapping Subproblems<\/h3>\n

    Overlapping subproblems<\/a> is the second key property that our problem must have to allow us to optimize using dynamic programming. Simply put, having overlapping subproblems means we are computing the same problem more than once.<\/p>\n

    Imagine you have a server that caches images. If the same image gets requested over and over again, you\u2019ll save a ton of time. However, if no one ever requests the same image more than once, what was the benefit of caching them?<\/p>\n

    This is exactly what happens here. If we don\u2019t have overlapping subproblems, there is nothing to stop us from caching values. It just won\u2019t actually improve our runtime at all. All it will do is create more work for us.<\/p>\n

    For an example of overlapping subproblems, consider the Fibonacci problem. Here is a tree of all the recursive calls required to compute the fifth Fibonacci number:<\/p>\n

    \"\"<\/p>\n

    Notice how we see repeated values in the tree. The number 3 is repeated twice, 2 is repeated three times, and 1 is repeated five times. Each of those repeats is an overlapping subproblem. There is no need for us to compute those subproblems multiple times because the value won\u2019t change. If we cache it, we can save ourselves a lot of work.<\/p>\n

    When Should I Use Dynamic Programming?<\/h3>\n

    To be absolutely certain that we can solve a problem using dynamic programming<\/a>, it is critical that we test for optimal substructure and overlapping subproblems. Without those, we can\u2019t use dynamic programming.<\/p>\n

    However, we can use heuristics to guess pretty accurately whether or not we should even consider using DP. This quick question can save us a ton of time.<\/p>\n

    All we have to ask is: Can this problem be solved by solving a combination problem?<\/p>\n