Leetcode2 动态规划的基础练习

前言

总解下最近刷到几道感觉比较有代表性的动规基础题。

题1

746.使用最小花费爬楼梯
数组的每个索引作为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 cost[i] (索引从0开始)。

每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。

您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。

输入: cost = [10, 15, 20]
输出: 15
解释: 最低花费是从cost[1]开始，然后走两步即可到阶梯顶，一共花费15。

例：输入: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
输出: 6
解释: 最低花费方式是从cost[0]开始，逐个经过那些1，跳过cost[3]，一共花费6。

例：输入: cost = [0, 0，0，1]
输出: 0
解释: 最低花费方式是cost[0]、cost[2]最后2阶直接上去。一共花费0。

代码

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int l=cost.length;
        int[] dp=new int[l+1];
        dp[0]=cost[0];
        if(l==1){ return (dp[0]);}
        dp[1]=cost[1];
        if(l==2){ return (dp[1]);}
        for(int i=2;i<l;i++){
            if(dp[i-1]>=dp[i-2])dp[i]=cost[i]+dp[i-2];
            else dp[i]=cost[i]+dp[i-1];
        }
        if(dp[l-1]>=dp[l-2])dp[l]=dp[l-2];
        else dp[l]=dp[l-1];
        return(dp[l]);
    }
}

注意点

边界判定

比如if(l==1){ return (dp[0]);} 如果没有这句，输入cost长度为1的话，cost[1]就会数组越界。
再比如 if(dp[i-1]>=dp[i-2])dp[i]=cost[i]+dp[i-2]; 等于号放在这条判断语句里，因为如果相邻cost相等则可走两阶跳过。
最后比如if(dp[l-1]>=dp[l-2])dp[l]=dp[l-2]; else dp[l]=dp[l-1]; 要单独拉出来写，因为最后判定顶层楼梯没有cost，放在循环里会cost越界。

题2

70.假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶
2. 2 阶

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

代码

class Solution {
    public int climbStairs(int n) {
        /*
        LinkedList<Integer> stack=new LinkedList<>();
        int res=0;
        if (n==1) return 1;
        stack.push(2);
        stack.push(1);
        while(!stack.isEmpty()){
            int temp=stack.pop();
            if(temp==n) res++;
            if(temp>n) continue;
            stack.push(temp+2);
            stack.push(temp+1);
        }
        return res;
        */
        int[] dp=new int[n];
        dp[0]=1;//第一阶
        if(n==1) return dp[0];
        dp[1]=2;
        for(int i=2;i<n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n-1];
        /*
        int a, b, temp;
        a=1;//第一阶
        if(n==1) return a;
        b=2;
        for(int i=2;i<n;i++){
            temp=a+b;
            a=b;
            b=temp;
        }
        return b;
        */
    }
    /*
    public void dfs(int n,int[] res){
        if(n==0) {
            res[0]++;
            return;
        }
        else if(n<0) return;
        n--;
        dfs(n,res);
        n--;
        dfs(n,res);
    }
    //out of time
    */
}

注意点

可以看到我最开始想用递归实现的dfs，可惜超时了。然后用动规就AC了。后来我尝试用三个数来节省空间（见注释），不过作用不大。后来我用栈实现dfs，没办法也超时。