维基百科中动态规划的部分讲解

Dynamic programming in computer programming

There are two key attributes that a problem must have in order for dynamic programming to be applicable: 

optimal substructure and overlapping subproblems. If a problem can be solved by combining optimal solutions to 

non-overlapping subproblems, the strategy is called "divide and conquer"(如果能通过合并子问题求解而不具有重叠子问题,用分治策略). 

This is why mergesort and quicksort are not classified as dynamic programming problems.

Optimal substructure(最优子结构) means that the solution to a given optimization problem can be obtained by the combination of optimal solutions to its subproblems(翻译:最优子结构含义是如果一个解是该问题的最优解,那么这个解也包含着子问题的最优解). Consequently, the first step towards devising a dynamic programming solution is to check whether the problem exhibits such optimal substructure. Such optimal substructures are usually described by means of recursion. For example, given a graph G=(V,E), the shortest path p from a vertex u to a vertex v exhibits optimal substructure: take any intermediate vertex w on this shortest path p. If p is truly the shortest path, then the path p₁ from u to w and p₂ from w to v are indeed the shortest paths between the corresponding vertices (by the simple cut-and-paste argument described in Introduction to Algorithms). Hence, one can easily formulate the solution for finding shortest paths in a recursive manner, which is what the Bellman-Ford algorithm or the Floyd-Warshall algorithm does.

Overlapping subproblems means that the space of subproblems must be small, that is, any recursive algorithm solving the problem should solve the same subproblems over and over, rather than generating new subproblems. For example, consider the recursive formulation for generating the Fibonacci series: F_i = F_i−1 + F_i−2, with base case F₁ = F₂ = 1. Then F₄₃ = F₄₂ + F₄₁, and F₄₂ = F₄₁ + F₄₀. Now F₄₁ is being solved in the recursive subtrees of both F₄₃ as well as F₄₂. Even though the total number of subproblems is actually small (only 43 of them), we end up solving the same problems over and over if we adopt a naive recursive solution such as this. Dynamic programming takes account of this fact and solves each subproblem only once.

Figure 2. The subproblem graph for the Fibonacci sequence. The fact that it is not a  treeindicates overlapping subproblems.

This can be achieved in either of two ways:^{[citation needed]}

• Top-down approach: This is the direct fall-out of the recursive formulation of any problem. If the solution to any problem can be formulated recursively using the solution to its subproblems, and if its subproblems are overlapping, then one can easilymemoize or store the solutions to the subproblems in a table. Whenever we attempt to solve a new subproblem, we first check the table to see if it is already solved. If a solution has been recorded, we can use it directly, otherwise we solve the subproblem and add its solution to the table.

• Bottom-up approach: Once we formulate the solution to a problem recursively as in terms of its subproblems, we can try reformulating the problem in a bottom-up fashion: try solving the subproblems first and use their solutions to build-on and arrive at solutions to bigger subproblems. This is also usually done in a tabular form by iteratively generating solutions to bigger and bigger subproblems by using the solutions to small subproblems. For example, if we already know the values of F₄₁and F₄₀, we can directly calculate the value of F₄₂.