Dynamic Programming (DP) Tutorial with Problems

Dynamic Programming

Table of Contents

• 1. Introduction to Dynamic Programming
• 2. Applications
• 3. Steps to solve a DP Problem
• 4. Approaches to Dynamic Programming
• 5. Example: Fibonacci Sequence
• 6. Example: Knapsack Problem
• 7. Leetcode Problems
• 8. References

1 Introduction to Dynamic Programming

Dynamic programming is a method for solving complex problems by breaking them down into simpler subproblems. It is applicable to problems exhibiting the properties of overlapping subproblems and optimal substructure, which are described below:

• Overlapping subproblems

  A problem has overlapping subproblems if it can be broken down into subproblems which are reused several times. For example, in the Fibonacci sequence, to calculate Fib(5), one needs Fib(4) and Fib(3), but Fib(4) itself requires Fib(3) and Fib(2). Here, Fib(3) is calculated multiple times, which is an overlapping subproblem.

• Optimal substructure

  A problem has an optimal substructure if an optimal solution to the problem contains within it optimal solutions to the subproblems. For instance, in the shortest path problem, if the shortest path from point A to point C goes through point B, then the shortest path from A to B is also part of the shortest path from A to C.

Heap and Priority Queue

Table of Contents

• 1. Introduction to Heap and Priority Queue
• 2. What are the applications of Heap and Priority Queue?
• 3. Heap in C++ standard library
• 4. Priority Queue in C++ standard library
  • 4.1. Minimum Priority Queue
• 5. The Applications of Priority Queues
• 6. References

1 Introduction to Heap and Priority Queue

A heap is a tree-based data structure that adheres to the heap property: in a max heap, any parent node's key (value) is greater than or equal to the keys of its children. Conversely, in a min heap, the key of a parent node is less than or equal to the keys of its children.

For more details, refer to Wikipedia: Heap (data structure).

A priority queue is an abstract data type similar to a regular queue or stack, where each element has an associated priority. Elements with higher priority are served before those with lower priority.

For more details, refer to Wikipedia: Priority queue.

Although they are conceptually different, priority queues are often referred to as heaps because they are commonly implemented using heaps.

The binary heap is a data structure that efficiently supports the basic priority queue operations. It allows O(1) performance for accessing the root, O(log n) for insertions and deletions, and O(n) for initially building the heap from a set of n elements.

Note that the time complexity to build a heap is O(n log n) using a top-down approach, whereas a bottom-up approach achieves O(n).

Java Collection Framework basics