leetcode150题-动态规划

动态规划

1.爬楼梯

问题描述：

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

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

我的求解：

C++ 复制代码

class Solution {
public:
    int climbStairs(int n) {
        // dp[i] = dp[i-1] + dp[i-2]
        if(n <= 0 ){
            return 0;
        }
        if(n <= 2){
            return n;
        }
        int *dp= (int *)malloc(sizeof(int)*n);
        dp[0] = 1;
        dp[1] = 2;
        for(int i = 2; i < n; i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n-1];
        
    }
};

官方答案:

C++ 复制代码

class Solution {
public:
    int climbStairs(int n) {
        int p = 0, q = 0, r = 1;
        for (int i = 1; i <= n; ++i) {
            p = q; 
            q = r; 
            r = p + q;
        }
        return r;
    }
};

可以不使用数组，进一步减少空间损耗，因为不需要知道中间值

打家劫舍

题目描述:

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。

我的求解：

C++ 复制代码

class Solution {
public:
    int rob(vector<int>& nums) {
        // dp[i][j] = k , i为存在的房间数
        // j为第i个房间是否偷（0/1）
        // k为在这种情况下能偷到的最多的钱
        int numsSize = nums.size();
        if(numsSize == 0){
            return 0;
        }
        if(numsSize == 1){
            return nums[0];
        }
        int **dp =(int **)malloc(sizeof(int*) * numsSize) ;
        //初始化数组
        for(int i = 0; i < numsSize; i++){
            dp[i] = (int*)malloc(sizeof(int)*2);
        }

        dp[0][0] = 0;
        dp[0][1] = nums[0];

        for(int i = 1; i < numsSize; i++){
            dp[i][0] = dp[i-1][0] > dp[i-1][1] ? dp[i-1][0]: dp[i-1][1];
            dp[i][1] = dp[i-1][0] + nums[i];
        }
        return dp[numsSize-1][0] > dp[numsSize-1][1] ?  dp[numsSize-1][0] :dp[numsSize-1][1];
    }
};

实际上还是没有彻底理解到动态规划的思维，不需要数组第二维来记录上一个房屋是否偷窃，数组的值是当有n间房屋时能偷到的最大值

那实际上直接使用一维数组即可

c++ 复制代码

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.empty()) {
            return 0;
        }
        int size = nums.size();
        if (size == 1) {
            return nums[0];
        }
        vector<int> dp = vector<int>(size, 0);
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for (int i = 2; i < size; i++) {
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[size - 1];
    }
};

即状态转移方程为 dp[i] = max(dp[i-1] , dp[i-2] + nums[i])

前者为不偷当前i能获得的最大值，后者为偷当前i（那不能偷i-1）能获得的最大值

单词拆分

问题描述：

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"]

输出: true

解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"]

输出: true

解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。

注意，你可以重复使用字典中的单词。

示例 3：

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]

输出: false

我的题解：

做不出来，我如下问题：

考虑这样的一种情况，s为"catsuper",wordDict = ["cats","super","cat"]。

是否有可能由于匹配了cats，而造成由于没有uper这个单词使得程序判断输出false的情况（而实际上由于存在cat+super，应该返回true）

但是实际上动态规划的方法能够完美解决这个"贪心陷阱"，因为它考虑了所有的可能拆分方式。

还是使用Java吧，那些api熟悉一点

官方题解：

Java 复制代码

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> wordDictSet = new HashSet(wordDict);
        // 注意，这里是length + 1,也就是说dp[0]是没用的
        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;
        for(int i = 1; i <= s.length(); i++){
            for(int j = 0; j < i; j++){
                // 这里dp[j]表示s的前j个字符，
                // 而s.subString(j,i)这里的j相当于s的第j+1个字符开始
                // 例如j=3，dp[3]表示s的前3个字符能不能匹配
                // 但是正是由于j=3，实际上取s.subString(3,i)的时候
                // 取的是实际上的第四个字符，也就是实际的j+1之后的字符
                // 所以这里没有遗漏字符也没有重复计算字符
                if(dp[j] && wordDictSet.contains(s.substring(j,i))){
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[s.length()];
    }
}

零钱兑换

问题描述：

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的

示例 1：

输入：coins = [1, 2, 5], amount = 11

输出：3

解释：11 = 5 + 5 + 1

示例 2：

输入：coins = [2], amount = 3

输出：-1

示例 3：

输入：coins = [1], amount = 0

输出：0

我的代码：

Java 复制代码

class Solution {
    public int coinChange(int[] coins, int amount) {
        if(coins.length == 0){
            return -1;
        }
        int[] dp = new int[amount+1];
        java.util.Arrays.fill(dp,-1);
        dp[0] = 0;
        
        for(int i = 0;i<=amount;i++){
            if (dp[i] == -1){
                continue;
            }
            for(int j = 0; j < coins.length; j++){
                // 将i+coins[j] <= amount改成
                // coins[j] <= amount - i
                // 即用减法来替代加法，防止溢出
                if(coins[j] <= amount - i){
                    
                    if(dp[i+coins[j]] == -1){
                        dp[i+coins[j]] = dp[i]+1;
                    }else{
                        dp[i+coins[j]] = Math.min(dp[i]+1,dp[i+coins[j]]);
                    }
                    
                }
            }

        }
        return dp[amount];
    }
}

在最开始没有考虑到加法溢出的情况

官方给的代码：

Java 复制代码

public class Solution {
    public int coinChange(int[] coins, int amount) {
        int max = amount + 1; //这里定义max为amout+1是很巧妙的
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, max);
        dp[0] = 0;
        for (int i = 1; i <= amount; i++) {
            for (int j = 0; j < coins.length; j++) {
                if (coins[j] <= i) { //这里没有去做加减，而是单纯的让硬币值不能超过当前的i值
                    dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
                }
            }
        }
        return dp[amount] > amount ? -1 : dp[amount];
    }
}