动态规划

图内向右或下走路

64.最小路径和
给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
示例:
输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

dp矩阵每一个点更新为当前位置的最小路径和，dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
类似的题目还有求路径数量，求矩形面积（得到当前位置只后还要进行相减）

class Solution {
    public int minPathSum(int[][] grid) {
        for(int i = 1; i < grid[0].length; i++){
            grid[0][i] += grid[0][i - 1];
        }
        for(int i = 1; i < grid.length; i++){
            grid[i][0] += grid[i - 1][0];
        }
        for(int i = 1; i < grid.length; i++){
            for(int j = 1; j < grid[0].length; j++){
                grid[i][j] += Math.min(grid[i - 1][j], grid[i][j - 1]);
            }
        }
        return grid[grid.length - 1][grid[0].length - 1];
    }
}

数组求区间个数

413.等差数列划分
数组 A 包含 N 个数，且索引从0开始。数组 A 的一个子数组划分为数组 (P, Q)，P 与 Q 是整数且满足 0<=P<Q<N 。
函数要返回数组 A 中所有为等差数组的子数组个数。
示例:
A = [1, 2, 3, 4]
返回: 3, A 中有三个子等差数组: [1, 2, 3], [2, 3, 4] 以及自身 [1, 2, 3, 4]。

区间必须是连续的
当前位置dp的值代表包含后三个数的等差数列的区间个数
区间长度加1，包含后三个数的等差数列区间个数就比区间长度减1的多1个，总的区间个数为所有位置dp之和。

class Solution {
    public int numberOfArithmeticSlices(int[] A) {
        if(A.length <= 2){
            return 0;
        }
        int[] dp = new int[A.length];
        int sum = 0;
        for(int i = 2; i < A.length; i++){
            if(A[i] - A[i - 1] == A[i - 1] - A[i - 2]){
                dp[i] += dp[i - 1] + 1;
                sum += dp[i];
            }
        }
        return sum;
    }
}

数的拆分

类似的有拆成完全平方数之和
343.整数拆分
给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。
示例 1:
输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。

对于每个数，dp记录当前的最大乘积，需要再遍历一遍和为这个数的乘积中的最大值，也就是两个for

class Solution {
    public int integerBreak(int n) {
        if(n == 2 || n ==3){
            return n - 1;
        }
        int []dp = new int[n + 1];
        dp[2] = 1;
        dp[3] = 2;
        for(int i = 4; i <= n; i++){
            int max = 0, left = 0, right = 0;
            for(int j = 2; j <= i/2; j++){
            	left = dp[j] < j ? j : dp[j];
            	right = dp[i - j] < i - j ? i - j : dp[i - j];
                max = Math.max(max, left * right);
            }
            dp[i] = max;
        }
        return dp[n];
    }
}