509.斐波那契数

代码：

class Solution {
    public int fib(int n) {
        if (n==0||n==1) {
            return n;
        }
        //1.确认dp数组和下标含义，一维dp数组，第i个数据为第i个数的的fn的值
        int[] dp = new int[n+1];
        //2.确认递推公式 fn = f(n-1)+f(n-2)
        //3.初始化dp数组,dp[0] = 0, dp[1] = 1
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i-1] + dp[i-2];
        }
        //4.确认遍历顺序
        //5.举例推导函数
        return dp[n];
    }
}

70.爬楼梯

class Solution {
    public int climbStairs(int n) {
        if (n==1) {
            return 1;
        }
        if (n==2) {
            return 2;
        }
        //确认dp数组的含义
        int[] dp = new int[n+1];
        //确认递推公式 dp[n] = dp[n-1] + dp[n-2];
        //确认dp数组的初始化
        dp[1] = 1;
        dp[2] = 2;
        //确认遍历顺序，开始遍历；
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i-1] + dp[i-2];
        }
        //举例推导函数
        return dp[n];
    }
}

746.使用最小花费爬楼梯

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        //确认dp数组；dp[i] 表示跳到第i层楼梯并且再继续往上爬的最小支付费用
        int[] dp = new int[cost.length];
        //确认递推公式 dp[i] = Math.min(dp[i-1], dp[i-2]) + cost[i];
        //dp数组初始化
        dp[0] = cost[0];
        dp[1] = cost[1];
        if (cost.length == 2) {
            return Math.min(dp[0], dp[1]);
        }
        //确认遍历的顺序
        for (int i = 2; i < cost.length; i++) {
            dp[i] = Math.min(dp[i-1], dp[i-2]) + cost[i];
        }
        //举例推导函数
        return Math.min(dp[cost.length-1], dp[cost.length-2]);
    }
}

62.不同路径

class Solution {
    public int uniquePaths(int m, int n) {
        /**
         * 这一题思考了一下，如果想到达终点，那么就只能从终点的上一个位置或者从终点的左侧位置到达，
         * 那么可以推导出 dp[m][n] = dp[m-1][n] + dp[m][n-1];
         **/
        if (m == 1||n==1) {
            return 1;
        }
        //确定dp数组
        int[][] dp = new int[m+1][n+1];
        //确认递推公式，dp[m][n] = dp[m-1][n] + dp[m][n-1];
        //dp数组的初始化,先给第二列和第二行的数据都调整为1
        for (int i = 1; i < m+1; i++) {
            dp[i][1] = 1;
        }
        for (int i = 1; i < n+1; i++) {
            dp[1][i] = 1;
        }
        //确认dp数组的遍历顺序,从第二列第二行开始遍历整个表格，
        for (int i = 2; i < m+1; i++) {
            for (int j = 2; j < n+1; j++) {
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        //举例推导函数
        return dp[m][n];
    }
}

63.不同路径II

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        if (obstacleGrid[0][0] == 1) {
            return 0;
        }
        if (obstacleGrid[m-1][n-1] == 1) {
            return 0;
        }
        if (m==1||n==1) {
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    if (obstacleGrid[i][j] == 1) {
                        return 0;
                    }
                }
            }
            return 1;
        }
        //确认dp数组
        int[][] dp = new int[m+1][n+1];
        //确认递推公式 递推函数依然为 dp[i][j] = dp[i][j-1] + dp[i-1][j];
        //初始化递推数组
        dp[1][1] = 1;
        //确认遍历顺序
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (i==1&&j==1) continue;
                if (obstacleGrid[i-1][j-1] == 1) {
                    dp[i][j] = 0;
                } else {
                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
                }
            }
        }
        //举例推导函数
        return dp[m][n];
    }
}

343.整数拆分

class Solution {
    public int integerBreak(int n) {
        if (n == 2) {
            return 1;
        }
        //确认dp数组含义
        int[] dp = new int[n+1];
        //确认递推公式, dp[i] = Math.max(dp[i], Math.max(dp[j]*(i-j), (i-j) * j));
        //dp数组初始化
        dp[2] = 1;
        //确认dp数组的遍历顺序
        for (int i = 3; i <= n; i++) {
            for (int j = 1; j < i-1; j++) {
                dp[i] = Math.max(dp[i], Math.max(dp[j] * (i-j), (i-j) * j));
            }
        }
        //举例推导结果函数
        return dp[n];
    }
}