二、动态规划

1.爬楼梯

题目描述

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

 我们到达第 n 个楼梯可以从第 n - 1 个楼梯和第 n - 2 个楼梯到达，因此第 n 个问题可以拆解成第 n - 1 个问题和第 n - 2 个问题，第 n - 1 个问题和第 n - 2 个问题又可以继续往下拆，直到第 0 个问题，也就是第 0 个楼梯 (起点)

“状态定义” 中我们已经定义好了状态，也知道第 i 个状态可以由第 i - 1 个状态和第 i - 2 个状态通过相加得到，因此递推方程就出来了 dp[i] = dp[i - 1] + dp[i - 2]

public int climbStairs(int n) {
    if (n == 1) {
        return 1;
    }

    int[] dp = new int[n + 1];  // 多开一位，考虑起始位置

    dp[0] = 0; dp[1] = 1; dp[2] = 2;
    for (int i = 3; i <= n; ++i) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp[n];
}

2.最大子序和。

题目描述

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

这题完全可以暴力求解。

或者从头开始累加到某个数时，和比最大的小了，那么可以从下一个数开始时重新累计，并记录每个小阶段的最大值。 

比如：第一个数-2，最大值为-2，直接从下一个数从头开始累加计算，最大变成1，然后遇到-3和变成负数直接从4开始重新计算，最大变成4.

当然，这个专题是动规。

问题的核心是子数组，子数组可以看作是一段区间，因此可以由起始点和终止点确定一个子数组，两个点中，我们先确定一个点，然后去找另一个点，比如说，如果我们确定一个子数组的截止元素在 i 这个位置，这个时候我们需要思考的问题是 “以 i 结尾的所有子数组中，和最大的是多少？”，然后我们去试着拆解，这里其实只有两种情况：

• i 这个位置的元素自成一个子数组
• i 位置的元素的值 + 以 i - 1 结尾的所有子数组中的子数组和最大的值

dp[i] 就是 “以 i 结尾的所有子数组的最大值”

dp[i] = Math.max(dp[i - 1] + array[i], array[i])

化简一下就成了：

dp[i] = Math.max(dp[i - 1], 0) + array[i]

public int maxSubArray(int[] nums) {
    if (nums == null || nums.length == 0) {
        return 0;
    }

    int n = nums.length;

    int[] dp = new int[n];

    dp[0] = nums[0];

    int result = dp[0];

    for (int i = 1; i < n; ++i) {
        dp[i] = Math.max(dp[i - 1], 0) + nums[i];
        result = Math.max(result, dp[i]);
    }

    return result;
}

其实从代码也可以看出，除了第一个数，其他只要前面的和比0小，直接就是以下一个数为dp；也就是法二。 

3.附加题

放出一道洛谷上的题：

# [NOIP2000 提高组] 方格取数

## 题目描述

设有 $N \times N$ 的方格图 $(N \le 9)$，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 $0$。如下图所示（见样例）:


某人从图的左上角的 $A$ 点出发，可以向下行走，也可以向右走，直到到达右下角的 $B$ 点。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字 $0$）。  
此人从 $A$ 点到 $B$ 点共走两次，试找出 $2$ 条这样的路径，使得取得的数之和为最大。

## 输入格式

输入的第一行为一个整数 $N$（表示 $N \times N$ 的方格图），接下来的每行有三个整数，前两个表示位置，第三个数为该位置上所放的数。一行单独的 $0$ 表示输入结束。

## 输出格式

只需输出一个整数，表示 $2$ 条路径上取得的最大的和。

## 样例 #1

### 样例输入 #1

```
8
2 3 13
2 6  6
3 5  7
4 4 14
5 2 21
5 6  4
6 3 15
7 2 14
0 0  0
```

### 样例输出 #1

```
67
```

## 提示

NOIP 2000 提高组第四题

之后将答案放评论区。

-----------------------------------------------

原来可以改博客。

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) {
        int N = 9;
        int[][][][] dp = new int[N][N][N][N];
        int[][] a = new int[N][N];
        int n, x, y, z;

        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();

        while (true) {
            x = scanner.nextInt();
            y = scanner.nextInt();
            z = scanner.nextInt();

            if (x == y && y == z && z == 0) {
                break;
            } else {
                a[x][y] = z;
            }
        }

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                for (int k = 1; k <= n; k++) {
                    for (int l = 1; l <= n; l++) {
                        dp[i][j][k][l] = Math.max(
                            Math.max(dp[i - 1][j][k - 1][l], dp[i - 1][j][k][l - 1]),
                            Math.max(dp[i][j - 1][k - 1][l], dp[i][j - 1][k][l - 1])
                        ) + a[i][j] + a[k][l];

                        if (i == k && l == j) {
                            dp[i][j][k][l] -= a[i][j];
                        }
                    }
                }
            }
        }

        System.out.println(dp[n][n][n][n]);
    }
}

这可以看成是一道多维dp；