Data Structures and Algorithms in Java[1].pdf - Fulvio Frisone

There are few algorithmic techniques that can take problems that seem to require
exponential time and produce polynomial-time algorithms to solve them. Dynamic
programming is one such technique. In addition, the algorithms that result from
applications of the dynamic programming technique are usually quite simple—
often needing little more than a few lines of code to describe some nested loops for
filling in a table.
The Components of a Dynamic Programming Solution
The dynamic programming technique is used primarily for optimization
problems, where we wish to find the "best" way of doing something. Often the
number of different ways of doing that "something" is exponential, so a bruteforce
search for the best is computationally infeasible for all but the smallest
problem sizes. We can apply the dynamic programming technique in such
situations, however, if the problem has a certain amount of structure that we can
exploit. This structure involves the following three components:
Simple Subproblems: There has to be some way of repeatedly breaking the
global optimization problem into subproblems. Moreover, there should be a
simple way of defining subproblems with just a few indices, like i, j, k, and so on.
Subproblem Optimization: An optimal solution to the global problem must be a
composition of optimal subproblem solutions. We should not be able to find a
globally optimal solution that contains suboptimal subproblems.
Subproblem Overlap: Optimal solutions to unrelated subproblems can contain
subproblems in common.
Having given the general components of a dynamic programming algorithm, we
next show how to apply it to the longest common subsequence problem.
12.5.3 Applying Dynamic Programming to the LCS
Problem
We can solve the longest common subsequence problem much faster than
exponential time using the dynamic programming technique. As mentioned above,
one of the key components of the dynamic programming technique is the definition
of simple subproblems that satisfy the subproblem optimization and subproblem
overlap properties.
Recall that in the LCS problem, we are given two character strings, X and Y, of
length n and m, respectively, and are asked to find a longest string S that is a
subsequence of both X and Y. Since X and Y are character strings, we have a natural
set of indices with which to define subproblems—indices into the strings X and Y.
Let us define a subproblem, therefore, as that of computing the value L[i, j],
779