16-今日两扣(LeetCode)-62-DP-M-413-DP-M

62. 不同路径-M

LeetCode

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

问总共有多少条不同的路径？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u7EKo1vM-1595822143076)(16-今日一扣(LeetCode)]-62-DP-M.assets/image-20200727092116398.png)

示例 1:

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右

示例 2:

输入: m = 7, n = 3
输出: 28

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

DP

此题和15扣-64有着相似的状态转移方程。

对于非边缘的任意一点，到达他的路径数应该是上侧点的路径数+左侧点路径数

考虑边界的情况，同64。

$g[i][j]$ 代表i,j点的到达方法数
$$\begin{gathered} g[0][0]=1 \\ g[i][j]=\{\begin{array}{l}g[i-1][j]+g[i][j]i>0,j>0\\ g[0][j-1]i=0,j>0(在第一列的情况)\\ g[i-1][0]i>0,j=0(在第一行的情况)\end{array} \end{gathered}$$

class Solution {
    public int uniquePaths(int m, int n) {
        // DP
        int [][] g = new int[m][n];
        // 其实位置0,0有一种方案
        g[0][0] = 1;
        for(int i = 1; i<m; i++){
            g[i][0] = g[i-1][0];
        }
        for(int j=1; j<n; j++){
            g[0][j] = g[0][j-1];
        }
        for(int i=1; i<m; i++){
            for(int j=1; j<n; j++){
                //这里空间复杂度可以优化
                g[i][j] = g[i-1][j]+g[i][j-1];
            }
        }
        return g[m-1][n-1];
    }
}

• 时间复杂度O(mn)
• 空间复杂度O(mn)

空间复杂度优化

每轮迭代使用的是第16行代码。

//优化到2n
//cur是本行。 pre是上一行
for (int i = 1; i < m;i++){
            for (int j = 1; j < n; j++){
                cur[j] = cur[j-1] + pre[j]; //只需要记录上一轮的，数组动态更新。
            }
            pre = cur.clone();
        }

//优化到O(n)
// 每次更新都用到上一行的和这一行之前的。所以cur[j] = cur[j](上一个行的) + cur[j-1](本行的j-1)。
// 即用一个数组同时维护了两行。未更新之前是上一行。更新了是这一行。
for (int i = 1; i < m;i++){
            for (int j = 1; j < n; j++){
                cur[j] += cur[j-1] ;
            }
        }

作者：powcai
链接：https://leetcode-cn.com/problems/unique-paths/solution/dong-tai-gui-hua-by-powcai-2/
来源：力扣（LeetCode）

DFS

超出时间范围。看下思路就可以。

class Solution {
    int ans = 0;
    public int uniquePaths(int m, int n) {
        dfs(0,0,m,n);
        return ans;
    }

    private void dfs(int i, int j, int m, int n){
        if(i == (m-1) && j==(n-1)){
            // 到达目标
            ans++;
            return ;
        }
        if(i >=m || j>=n){
            //越界
            return ;
        }
        dfs(i+1,j,m,n);
        dfs(i,j+1,m,n);
    }
}

413. 等差数列划分-M

LeetCode

如果一个数列至少有三个元素，并且任意两个相邻元素之差相同，则称该数列为等差数列。

例如，以下数列为等差数列:

1, 3, 5, 7, 9
7, 7, 7, 7
3, -1, -5, -9

以下数列不是等差数列。

1, 1, 2, 5, 7

数组 A 包含 N 个数，且索引从0开始。数组 A 的一个子数组划分为数组 (P, Q)，P 与 Q 是整数且满足 0<=P<Q<N 。

如果满足以下条件，则称子数组(P, Q)为等差数组：

元素 A[P], A[p + 1], …, A[Q - 1], A[Q] 是等差的。并且 P + 1 < Q 。

函数要返回数组 A 中所有为等差数组的子数组个数。

示例:

A = [1, 2, 3, 4]

返回: 3, A 中有三个子等差数组: [1, 2, 3], [2, 3, 4] 以及自身 [1, 2, 3, 4]。

题解

动态规划

假设已存在一个等差数列$a_k,a_{k+1}...a_{k+m-1}$，所包含的等差数列个数为sum，我们在后边加一个$a_{k+m}$后结果是什么呢？

• 如果$a_{k+m}$不符合等差数列，那么结果仍然为sum。
• 如果后加入的数$a_{k+m+1}$符合前一个等差数列，那么总的个数为sum+增加的数量

增加的数量是多少呢？ 增加后个数为m+1个，所有包含$a_{k+m}$的子列都属于新增加的数量。所以应该是m+1-2个，这个也就是我们需要记录的在dp数组的里的标记。我们的dp数组存储的是如果新增加的数字满足等差数列，那么该数会增加多少个结果。

$a_{k+m-1}$的数量是m-1+1-2 = m-2。与$a_{k+m}$相差为1。 所以dp数组里每次增加的个数是可以用上次的+1来计算。即dp[m] = dp[m-1]+1

class Solution {
    public int numberOfArithmeticSlices(int[] A) {
        int[] dp = new int[A.length];
        Arrays.fill(dp, 0);
        int sum = 0;
        //从2开始，应为至少3个才能算是等差数列
        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; // 其实第i个
                sum+=dp[i];
            }
        }
        return sum;
    }
}