刷题计划——动态规划dynamic programming(四)

322. 零钱兑换(中等)

题目：

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

示例 1:

输入: coins = [1, 2, 5], amount = 11
输出: 3 
解释: 11 = 5 + 5 + 1
示例 2:

输入: coins = [2], amount = 3
输出: -1

根据leetcode的这一解析凑零钱问题而写下此道题解。

要完成金额为11的最少硬币组合(原问题)，而当知道了金额为10的最少硬币组合之后(子问题)，在子问题上加一，就得到原问题最优解。

将所求金额设为状态，该状态总共有金额个，dp[i] 表示金额为i 所需要的最少硬币数量。例如，当i为5时，运用示例1中的硬币数量：

1. 遍历coins数组，当i - coins[j] < 0 时，说明i无法被**coins[j]**构成，因此直接选择下一个硬币
2. 当i - coins[j] >= 0 时说明可以，此时选择将**i - coins[j]**金额所需的最少硬币组合加1， 与当前最小次数比较。

状态方程：

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        if(amount == 0){
            return 0;
        }
        if(amount < 0){
            return -1;
        }
        vector<int> dp(amount+1, amount+1);
        dp[0] = 0;
        for(int i = 0; i <= amount; i++){
            for(auto coin: coins){
                if(i - coin < 0){
                    continue;   
                }
                //	此时硬币大小为coin, 所求的金额为i, 
                //	若使用此硬币，就要选择最接近金额i的方案，
                //	dp[i-coin]+1 表示加上当前硬币coin之后最接近金额i的方案
                //	+1 表示，使用此硬币就会带来以此“使用”的记录
                dp[i] = min(dp[i], dp[i-coin]+1);
            }
        }
        return (dp[amount] == amount + 1) ? -1 : dp[amount];
    }
};

300. 最长上升子序列(中等)

题目：

给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4 
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

双重遍历的暴力法就不再多提，原本想从传统的动态规划法入手，但看到一篇进阶解法之后，突然想到还能这么解决这道问题。

作者构建了拥有最长上升子序列的数组dp，而这个数组的大小也就是最长上升子序列的长度。

1. 该dp数组的第一个数为最长上升子序列中的最小值，最后一个数为最大值。这样在遍历中，一旦发现有小于dp数组中第一个数的值，就将dp[0] 置为该数。
2. 其实具体思想如下，一旦发现有小于dp数组中最小数的数字，表明该数肯定也小于dp数组的其他数，相当与用该数替换了这个dp数组中的最小数，这对于已经成型了的原dp数组不造成影响，同理也可针对dp数组中的其它数。

具体思路：

• 构建一个存储最长上升序列的数组dp，将其第一个数置为nums[0]
• 遍历该数组，若nums[i] > dp[dp.size - 1]， 就将**nums[i]**插入dp数组末尾
• 若nums[i] < dp[dp.size - 1]， 就在dp数组中查找小于nums[i]的数，将其替换为nums[i]
• 在完成遍历后，返回dp.size

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size() <= 1){
            return nums.size();
        }
        int numsSize = nums.size();
        vector<int> dp;
        dp.push_back(nums[0]);
        for(int i = 1; i < numsSize; i++){
            if(nums[i] > dp.back()){
                dp.push_back(nums[i]);
            }
            else{
            	//	lower_bound 使用二分法，因此总体时间复杂度可以达到 O(NlogN)
                auto it = lower_bound(dp.begin(), dp.end(), nums[i]);
                *it = nums[i];
            }
        }
        return dp.size();
    }
};

139. 单词拆分(中等)

题目：

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

• 拆分时可以重复使用字典中的单词。
• 你可以假设字典中没有重复的单词。

示例 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

拆分问题可以抽象为寻求子问题的解。

首先，从示例1来看，可以将“leetcode”字符串划分为子串s1“leet”和子串s2“code”， 在字典wordict中查询是否存在着两个子串，若存在且两个子串可以构成原字符串s，就将其设置为true。

由于涉及到分割子串的问题，可以通过递归的方案来解决，但也可以通过动态规划的办法来解决。

首先，需要定义状态dp[i]，其表示在[0, i] 这个长度范围内的子串是否可以被字典中的单词表示出来，若能表示出来dp[i] = true，若不能则dp[i] = false。 解决状态定义之后，如何进行状态转移就成了下一个问题。

从字符串“leetcode”的遍历来看，其dp数组是这样：
$$\begin{array}{cccccccc}false& false& false& true& false& false& false& true\\ 0& 1& 2& 3& 4& 5& 6& 7\end{array}$$

index 为3时表示的是子串“leet”，该子串对应的是字典中的第一个元素，因此dp[3] = true, 同理最后求得dp[7] = true。

我们使用 n+1 大小数组的dp ，其中 n 是给定字符串的长度。

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        vector<bool> dp(s.size()+1, 0);
        dp[0] = 1;
        for(int i = 0; i <= s.size(); i++){
            for(auto word: wordDict){
            	//	查看当前子串在字典中是否存在
                int wordSize = word.size();
                if(i >= wordSize){
                    int cur = s.compare(i-wordSize, wordSize, word);
                    //	cur表示在以[i, i-wordSize]范围内的字符是否可以组成一个由在字典中存在元素拼接而成的字符串
                    //	dp[i-wordSize]表示，组成当前子字符串之后，前面的字符串是否已经可以组成一个在字典中存在元素拼接而成的字符串
                    if(!cur && dp[i-wordSize]){
                        dp[i] = true;
                    }
                }
            }
        }
        return dp[s.size()];
    }
};