One example of a dynamic programming problem is the "Longest Common Subsequence" (LCS) problem.

  In this problem, given two sequences (e.g., strings) A and B, the task is to find the length of the longest common subsequence that is common to both sequences. A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing their order.

  Here's an example to illustrate the problem:

  Sequence A: "ABCDGH"

  Sequence B: "AEDFHR"

  The longest common subsequence for these two sequences is "ADH" with a length of 3. Notice that the subsequence doesn't have to be contiguous and can skip elements.

  The dynamic programming approach to solve the LCS problem involves building a memoization table (usually a 2-dimensional array) to store the solutions to subproblems. The table is filled iteratively, and each cell represents the length of the longest common subsequence for a portion of both sequences.

  The subproblem solutions are built from smaller subproblems until the final solution is obtained. The memoization table is populated by comparing characters from both sequences and updating the table based on the following rules:

  - If the characters match, add 1 to the length of the LCS from the previous subproblem.

  - If the characters don't match, take the maximum of the LCS from the subproblems of excluding the current character from either sequence.

  By the end, the bottom-right cell of the memoization table holds the length of the longest common subsequence, which can be returned as the final result.

  The time complexity of the dynamic programming algorithm for the LCS problem is O(m*n), where m and n are the lengths of the sequences A and B, respectively.