面试题笔记-算法-力扣-动态规划

一个简单的动态规划问题。
已知机器人只能向右或向下移动，则移动到当前位置的前一个位置只能是其的左边或者上边。所以可以得出移动当前的位置的路径条数为到其上方和其左边路径条数之和： dp[i][j]=dp[i-1][j]+dp[i][j-1]
先考虑边框情况：
但由于边框不能获得对应的dp[i][j]=dp[i-1][j]+dp[i][j-1]，会造成数组的溢出，所以我们需要对其进行赋初值。
考虑到有障碍物，当遇到障碍物后，后面的路是不能走的，所以障碍物及其之后的位置都赋值为0

int m = obstacleGrid.length;//宽
        int n = obstacleGrid[0].length;//长
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; ++i) {
            if(obstacleGrid[i][0] == 1){
                while (i < m) {
                    dp[i][0] = 0;
                    i++;
                }
                break;
            }
            dp[i][0] = 1;
        }
        for (int j = 0; j < n; ++j) {
            if(obstacleGrid[0][j] == 1){
                while (j < n) {
                    dp[0][j] = 0;
                    j++;
                }
                break;
            }
            dp[0][j] = 1;
        }

在考虑内部情况：
简单的dp算法，但如果遇到了障碍物，那要把障碍物位置设置为0，因为障碍物是不能通过的。
完整代码如下:

for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if(obstacleGrid[i][j] == 1) dp[i][j] = 0;
                else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }

完整如下:

public class uniquePathsWithObstacles {
    public static void main(String[] args) {
        int[][] nums = {{0,0,0},{0,1,0},{0,0,0}};
        System.out.println(uniquePathsWithObstacles(nums));
    }

    public static int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;//宽
        int n = obstacleGrid[0].length;//长
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; ++i) {
            if(obstacleGrid[i][0] == 1){
                while (i < m) {
                    dp[i][0] = 0;
                    i++;
                }
                break;
            }
            dp[i][0] = 1;
        }
        for (int j = 0; j < n; ++j) {
            if(obstacleGrid[0][j] == 1){
                while (j < n) {
                    dp[0][j] = 0;
                    j++;
                }
                break;
            }
            dp[0][j] = 1;
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if(obstacleGrid[i][j] == 1) dp[i][j] = 0;
                else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];

    }
}

读题可知，到当前位置的总和是由该位置的左边或上边决定的。所以还是一道动态规划的题目。
完整代码如下:

 dp[i][j] = grid[i][j] + (dp[i - 1][j] ;
 或者
 dp[i][j] = grid[i][j] + dp[i][j - 1]);
 由于求最小值
 dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];

 public static int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }

        for (int j = 1; j < n; j++) {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                //dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
                dp[i][j] = grid[i][j] + (dp[i - 1][j] < dp[i][j - 1] ? dp[i - 1][j] : dp[i][j - 1]);
            }
        }
        return dp[m - 1][n - 1];
    }

起步先找规律，一般当前位置的可能性与前边位置是有关的

//发现了 f(n) = f(n-1) + f(n-2)
1 1 1
2 11 2 2
3 111 12 21 3
4 1111 112 121 211 22 5
5 11111 1112 1121 1211 2111 122 212 221 8
6 111111 11112 11121 11211 12111 21111 1122 1212 2112 2121 2211 1221 222 13

可以考虑使用递归算法
完整代码如下:

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

    public static int getSum(int n) {
        if(n == 1) return 1;
        if(n == 2) return 2;
        return getSum(n - 1) + getSum(n - 2);
    }

但递归超时了，逆向超时，那我们正向来
使用动态规划创建一个数组用于存储前两个位置的总和 和 当前位置总和

public int climbStairs(int n) {
        if(n == 1)return 1;
        if(n == 2)return 2;
        int[] dp = new int[3];
        //0 1 分别表示前两个位置的总和
        dp[0] = 1;
        dp[1] = 2;
        for (int i = 3; i <= n; i++) {
            //dp[2] 表示当前位置的总和
            dp[2] = dp[0] + dp[1];
            //根据下次遍历更改数值
            dp[0] = dp[1];
            dp[1] = dp[2];
        }
        return dp[2];
    }

当前数的可能由之前的决定则可以采用动态规划

public int numDecodings(String s) {
        int n = s.length();
        s = " " + s;
        char[] cs = s.toCharArray();
        int[] f = new int[n + 1];
        f[0] = 1;
        for (int i = 1; i <= n; i++) { 
            // a : 代表「当前位置」单独形成 item
            // b : 代表「当前位置」与「前一位置」共同形成 item
            int a = cs[i] - '0', b = (cs[i - 1] - '0') * 10 + (cs[i] - '0');
            // 如果 a 属于有效值，那么 f[i] 可以由 f[i - 1] 转移过来
            if (1 <= a && a <= 9) f[i] = f[i - 1];
            // 如果 b 属于有效值，那么 f[i] 可以由 f[i - 2] 或者 f[i - 1] & f[i - 2] 转移过来
            if (10 <= b && b <= 26) f[i] += f[i - 2];
        }
        return f[n];
    }

可以利用获得对应字符最短路径的方式
进行画图求解

 public boolean isInterleave(String s1, String s2, String s3) {
        int m = s1.length(), n = s2.length();
        if (s3.length() != m + n) return false;
        // 动态规划，dp[i,j]表示s1前i字符能与s2前j字符组成s3前i+j个字符；
        boolean[][] dp = new boolean[m+1][n+1];
        dp[0][0] = true;
        for (int i = 1; i <= m && s1.charAt(i-1) == s3.charAt(i-1); i++) dp[i][0] = true; // 不相符直接终止
        for (int j = 1; j <= n && s2.charAt(j-1) == s3.charAt(j-1); j++) dp[0][j] = true; // 不相符直接终止
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                dp[i][j] = (dp[i - 1][j] && s3.charAt(i + j - 1) == s1.charAt(i - 1))
                    || (dp[i][j - 1] && s3.charAt(i + j - 1) == s2.charAt(j - 1));
            }
        }
        return dp[m][n];
    }