hot100 |十六、多纬动态规划

1-leetcode62. 不同路径

注意：√

1. 注意一下初始化的时候第一行和第一列都是1，因为只有一个方向一直走能到这个位置的答案，所以路径为1

    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }

2-leetcode64. 最小路径和

注意：√

1. 注意把判断放在for循环内部会简洁很多
2. 之前想的是先赋初始值然后再操作，现在发现题解中的直接判断会好很多

    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i==0&&j==0){
                    dp[i][j] = grid[i][j];
                } else if (i == 0) {
                    dp[i][j] = dp[i][j-1]+grid[i][j];
                } else if (j == 0) {
                    dp[i][j] = dp[i-1][j]+grid[i][j];
                }else {
                    dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
                }
            }
        }
        return dp[m-1][n-1];
    }

3-leetcode5. 最长回文子串

注意：×

1. 第一反应是判断当前i的长度是奇数还是偶数
2. 看了题解发现直接用两次，奇数就传两个一样的就行了，非常方便也不需要进行判断的
3. 注意子函数写的时候while里面的判断
4. 返回的时候其实i 和 i1都是不可取的，但是substring函数是左闭右开，所以这里是左边需要+1右边不用

    public String longestPalindrome(String s) {
        String ans = "";
        for (int i = 0; i < s.length(); i++) {
            String s1 = getPalindrome(s, i, i);
            String s2 = getPalindrome(s, i, i + 1);
            ans = ans.length()>s1.length()? ans : s1;
            ans = ans.length()>s2.length()? ans : s2;
        }
        return ans;
    }

    private String getPalindrome(String s, int i, int i1) {
        while (i>=0 && i1<s.length() && s.charAt(i)==s.charAt(i1)){
            i--;
            i1++;
        }
        return s.substring(i+1,i1);
    }

4-leetcode1143. 最长公共子序列

注意：×

1. 注意核心的思想，如果这两个字符相等，那这个位置的值就是没有这两个字符的时候，直接+1
2. 如果两个字符不相等，就是上一个格子或者左边一个格子的结果

    public int longestCommonSubsequence(String text1, String text2) {
        int n = text1.length();
        int m = text2.length();
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 0; i < n + 1; i++) {
            dp[i][0] = 0;
        }
        for (int i = 0; i < m + 1; i++) {
            dp[0][i] = 0;
        }

        for (int i = 1; i < n + 1; i++) {
            for (int j = 1; j < m + 1; j++) {
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    dp[i][j] = 1 + dp[i - 1][j - 1];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[n-1][m-1];
    }

5-leetcode72. 编辑距离

注意：√

1. 注意dp数组的初始化
2. 注意两个字符相等的时候dp的值是不变的
3. 当两个字符不等的时候，从三个格子中选取最需要的那个值

    public int minDistance(String s1, String s2) {
        int n = s1.length();
        int m = s2.length();
        int[][] dp = new int[n + 1][m + 1];

        // base case
        for (int i = 0; i < n + 1; i++) {
            dp[i][0] = i;
        }
        for (int i = 0; i < m + 1; i++) {
            dp[0][i] = i;
        }

        // 状态转移
        for (int i = 1; i < n + 1; i++) {
            for (int j = 1; j < m + 1; j++) {
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = mymin(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1;
                }
            }
        }
        return dp[n][m];
    }

    /**
     * 自定义的三个数取最小值
     *
     * @param a dp[i-1][j-1]
     * @param b dp[i-1][j],
     * @param c dp[i][j-1]
     * @return
     */
    private int mymin(int a, int b, int c) {
        return Math.min(a, Math.min(b, c));
    }