2021-09-25

    确定dp数组（dp table）以及下标的含义
    确定递推公式
    dp数组如何初始化
    确定遍历顺序
    举例推导dp数组


斐波那契数列
class Solution {
    public int fib(int n) {
        if(n==0||n==1) return n;
        int sum;
        int m=0,k=1;
        for(int i=0;i<n;i++)
        {
            sum=m+k;
            m=k;
            k=sum;
        }
        return m;
    }
}
爬楼梯
class Solution {
    public int climbStairs(int n) {
        if(n==1) return 1;
        if(n==2) return 2;
        int m=1,k=2,sum;
        for(int i=2;i<n;i++)
        {
            sum=m+k;
            m=k;
            k=sum;
        }
        return k;
    }
}
爬楼梯的最小消费
class Solution {
    public int minCostClimbingStairs(int[] cost) {
        if (cost == null || cost.length == 0) {
            return 0;
        }
        if (cost.length == 1) {
            return cost[0];
        }
        int[] dp = new int[cost.length];
        dp[0] = cost[0];
        dp[1] = cost[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]);
    }
}
不同路径
class Solution {
    public int uniquePaths(int m, int n) {
        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]=1;
                }
                else
                {
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                }
            }

        }
        return dp[m-1][n-1];
    }
}
不同路径Ⅱ
class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m=obstacleGrid.length,n=obstacleGrid[0].length;
        int[][] dp=new int[m][n];
        dp[0][0] = 1 - obstacleGrid[0][0];
        for(int i=1;i<m;i++)
        {
            if (obstacleGrid[i][0] == 0 && dp[i - 1][0] == 1) {
                dp[i][0] = 1;
            }
        }
        for(int j=1;j<n;j++)
        {
            if(obstacleGrid[0][j]==0&&dp[0][j-1]==1)
            {
                dp[0][j]=1;
            }
        }
         for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m- 1][n - 1];
    }
}

整数拆分
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-1;j++)
            {
                dp[i]=Math.max(dp[i],Math.max((i-j)*j,dp[i-j]*j));
            }
        }
        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[i]+dp[j-1]*dp[i-j];
            }
        }
        return dp[n];
    }
}