代码随想录第38-40天动态规划|● 理论基础 ● 斐波那契数 ● 爬楼梯 ● 使用最小花费爬楼梯 ● 不同路径 ● 不同路径② ● 整数拆分 ● 不同的二叉搜索树

斐波那契数

思路一：递归

class Solution {
    public int fib(int n) {
        if(n==0)return 0;
        if(n==1)return 1;
        return fib(n-1)+fib(n-2);
    }
}

思路二：动态规划

代码1：整体维护数组

class Solution {
    public int fib(int n) {
        // 0和1
        if(n<2)return n;
        //确定dp数组
        int[] dp=new int[n+1];
        //初始化
        dp[0]=0;
        dp[1]=1;
        //确定遍历顺序
        for(int i=2;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

代码2：两个变量

class Solution {
    public int fib(int n) {
        // 0和1
        if(n<2)return n;
        //确定dp数组+初始化
        int a=0,b=1,c=0;

        //确定遍历顺序
        for(int i=2;i<=n;i++){
            c=a+b;
            a=b;//后移一位
            b=c;
        }
        return c;
    }
}

爬楼梯

思路：

代码：

class Solution {
    public int climbStairs(int n) {
        if(n<=1)return n;
        //确定dp数组
        int[] dp=new int[n+1];
        //初始化
        dp[1]=1;dp[2]=2;
        //递推公式
        // dp[i]=dp[i-1]+1或者dp[i-2]+2;
        for(int i=3;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

使用最小花费爬楼梯

思路：

代码：

dp表示到达第i个花费的钱数，那么dpi就是前一个或者前两个的dp+cost的价格，然后取min

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int n=cost.length;
        int[] dp=new int[n+1];
        // dp[0]=0;
        dp[0]=0;
        dp[1]=0;
        // dp[2]=Math.min(cost[1],cost[0]);
        for(int i=2;i<=n;i++){
            dp[i]=Math.min(cost[i-1]+dp[i-1],cost[i-2]+dp[i-2]);
        }
        return dp[n];
    }
}

● 不同路径

思路：

代码一：二维数组

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for(int i=0;i<n;i++){
            dp[0][i]=1;
        }
        for(int i=0;i<m;i++){
            dp[i][0]=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];
    }
}

代码二：滚动数组

初始化第一行都为1
按照行遍历，每次dp[i]都由前一个dp[i-1]+当前dp[i]（表示上一行向下的方法）覆盖

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

● 不同路径②

思路：

代码一：二维数组

class Solution {
    public 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&&obstacleGrid[i][0]!=1;i++){
            dp[i][0]=1;
        }
        for(int i=0;i<n&&obstacleGrid[0][i]!=1;i++){
            dp[0][i]=1;
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j]=obstacleGrid[i][j]==1?0:dp[i-1][j]+dp[i][j-1];
            }
        }        
        return dp[m-1][n-1];

    }
}

代码二：一维数组

注意：在遍历行列m和n时，j列要从0开始(因为第一(i=0)列的初始化没有考虑障碍物的情况，要单独进行赋值)

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[] dp=new int[n];
        // for(int i=0;i<m&&obstacleGrid[i][0]!=1;i++){
        //     dp[i][0]=1;
        // }
        for(int i=0;i<n&&obstacleGrid[0][i]!=1;i++){
            dp[i]=1;
        }
        for(int i=1;i<m;i++){
            for(int j=0;j<n;j++){
                if (obstacleGrid[i][j] == 1) {
                    dp[j] = 0;
                } else if (j != 0) {
                    dp[j] += dp[j - 1];
                }
            }
        }        
        return dp[n-1];

    }
}

343. 整数拆分

思路：

动归五部曲

代码：

i从3开始 j从1开始 到i的一半。
dp[i]应该随时更新

class Solution {
    public int integerBreak(int n) {
        int[] dp=new int[n+1];
        dp[2]=1;
        for(int i=3;i<=n;i++){
            for(int j=1;j<=i/2;j++){
                // j变动时dp[i]也变化，所以应该实时更新dp[i]
                dp[i]=Math.max(Math.max(j*(i-j),j*dp[i-j]),dp[i]);
            }
        }
        return dp[n];
    }
}

不同的二叉搜索树

思路：

代码：

class Solution {
    public int numTrees(int n) {
        int[] dp=new int[n+1];
        dp[0]=1;
        dp[1]=1;
        for(int i=2;i<=n;i++){
            for(int j=1;j<=i;j++){
                dp[i]+=dp[j-1]*dp[i-j];
            }
        }
        return dp[n];
    }
}