请详细说明动态规划问题的解题思路，并给出两个例子。其中一个例子应较为基础，另一个应具有难度

动态规划是一种算法思想，通常用于解决优化问题。它通常用于需要通过求解子问题的最优解来求解原始问题的情况。动态规划通常由以下几个步骤组成：

1.定义子问题：将原问题分解为若干个子问题，并定义每个子问题的解。

2.定义状态：定义状态表示原问题或子问题的解。

3.状态转移方程：根据子问题的解和状态，定义原问题或子问题的解。

4.计算顺序：按照一定的顺序计算每个状态的值，通常是从小到大计算。

5.计算原问题的解：根据计算出的状态值，计算原问题的解。

下面给出两个例子：

例子1：爬楼梯问题

有一个n级的楼梯，每次可以走1步或2步，问有多少种不同的走法。

1.定义子问题：假设f(i)表示走到第i级楼梯的不同走法数。

2.定义状态：状态表示为f(i)。

3.状态转移方程：f(i) = f(i-1) + f(i-2)。

4.计算顺序：按照从小到大的顺序计算每个状态的值。

5.计算原问题的解：原问题的解为f(n)。

Java代码如下：

public int climbStairs(int n) {
    if (n == 1) {
        return 1;
    }
    int[] f = new int[n+1];
    f[1] = 1;
    f[2] = 2;
    for (int i = 3; i <= n; i++) {
        f[i] = f[i-1] + f[i-2];
    }
    return f[n];
}

例子2：最长公共子序列问题

给定两个字符串s1和s2，求它们的最长公共子序列。

1.定义子问题：假设f(i,j)表示s1前i个字符和s2前j个字符的最长公共子序列长度。

2.定义状态：状态表示为f(i,j)。

3.状态转移方程：如果s1[i] == s2[j]，则f(i,j) = f(i-1,j-1) + 1；否则f(i,j) = max(f(i-1,j), f(i,j-1))。

4.计算顺序：按照从小到大的顺序计算每个状态的值。

5.计算原问题的解：原问题的解为f(n,m)，其中n和m分别是s1和s2的长度。

Java代码如下：

public int longestCommonSubsequence(String text1, String text2) {
    int n = text1.length();
    int m = text2.length();
    int[][] f = new int[n+1][m+1];
    for (int i = 1; i <= n; i++) {
        char c1 = text1.charAt(i-1);
        for (int j = 1; j <= m; j++) {
            char c2 = text2.charAt(j-1);
            if (c1 == c2) {
                f[i][j] = f[i-1][j-1] + 1;
            } else {
                f[i][j] = Math.max(f[i-1][j], f[i][j-1]);
            }
        }
    }
    return f[n][m];
}

这两个例子分别是动态规划问题的基础和难度较高的例子。在实际应用中，动态规划可以解决许多优化问题，例如背包问题、最长上升子序列问题、矩阵链乘法问题等。