动态规划

例题1：爬楼梯：

解题思路：
最后一步可能走了一阶或者两阶，两种情况，所以很容易得出递归方程。

算法优化：
可以采用数组的方式模拟迭代过程，即
dp[i] = dp[i-1]+dp[i-2]

代码如下：

class Solution {
    public int climbStairs(int n) {
        if(n==1) return 1;
        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        for(int i = 2;i<n;i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n-1];
    }
}

例题2：打家劫舍Ⅱ

先不考虑边界，很容易得到状态转移方程：

考虑边界，可以分两步
Math.max(robRange(nums, 0, length - 2), robRange(nums, 1, length - 1));
其中robRange方法是上述状态转移方程的实现

class Solution {
    public int rob(int[] nums) {
        int length = nums.length;
        if (length == 1) {
            return nums[0];
        } else if (length == 2) {
            return Math.max(nums[0], nums[1]);
        }
        return Math.max(robRange(nums, 0, length - 2), robRange(nums, 1, length - 1));
    }

    public int robRange(int[] nums, int start, int end) {
        int first = nums[start], second = Math.max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; i++) {
            int temp = second;
            second = Math.max(first + nums[i], second);
            first = temp;
        }
        return second;
    }
}

例题3：青蛙过河

我们也可以使用动态规划的方法，令 \textit{dp}[i][k]dp[i][k] 表示青蛙能否达到「现在所处的石子编号」为 ii 且「上一次跳跃距离」为 kk 的状态。

状态转移方程：

j 代表了青蛙的「上一次所在的石子编号」，满足 stones[i] - stones[j] = k。
代码如下：

class Solution {
    public boolean canCross(int[] stones) {
        int n = stones.length;
        boolean[][] dp = new boolean[n][n];
        dp[0][0] = true;
        for (int i = 1; i < n; ++i) {
            if (stones[i] - stones[i - 1] > i) {
                return false;
            }
        }
        for (int i = 1; i < n; ++i) {
            for (int j = i - 1; j >= 0; --j) {
                int k = stones[i] - stones[j];
                if (k > j + 1) {
                    break;
                }
                dp[i][k] = dp[j][k - 1] || dp[j][k] || dp[j][k + 1];
                if (i == n - 1 && dp[i][k]) {
                    return true;
                }
            }
        }
        return false;
    }
}