[leetcode] WordBreak && MaximumProductSubarray

最新推荐文章于 2024-11-19 23:58:32 发布

UpCoderXH

最新推荐文章于 2024-11-19 23:58:32 发布

阅读量183

点赞数

分类专栏： ACM/算法文章标签： leetcode Word Break Maximum Product Subarray

本文链接：https://blog.csdn.net/liangdong2014/article/details/89978784

版权

ACM/算法专栏收录该内容

72 篇文章 0 订阅

订阅专栏

今天这两道题是两道动态规划的题目。

Word break

问题描述：给定一个字符串s，和一个字典d。试问有没有办法使用d中的字符串构造出s。d中的每个字符串可以使用多次。
分析
- 最直观的解法肯定是暴力搜索。我们遍历d中所有组合，看能否构成s。如果不能则返回false，如果可以则返回true。
- 这种暴力搜索肯定是超时，那么我们是否还有其他做法呢？
- 我们试想如果s中的每个字符c，我们都可以在d中找到一个word是以c结尾，并且S中字符串c前 $Len_{word}$ 和word也一致。那么我们只需要再遍历下一个字符就好。
- 假设匹配的word的长度是L。字符C所在的位置是i
- dp[i] 表示以i位置为结尾的子字符串是否能以dict构造。如果可以则true，如果不可以则为false。这样我们就把大问题化成了一个小问题。
- dp[i] = (S[i-Len:i] == word) && dp[i-Len-1]。解释：也就是说如果当前字母是匹配的，那么dp[i]还取决于dp[i-Len-1]必须他们也是True了，才可以。
- 至此，我们就已经找到了转移方程。

bool wordBreakDP(string s, vector<string>& wordDict){
        // 利用动态规划的思路来解决
        int len = (int) s.length();
        if(len == 0)
            return true;
        int size = (int) wordDict.size();
        if(size == 0)
            return false;
        bool dp[len]; // 每一位表示的是，以s中对应位置结束的字符在wordDict中是否存在
        // dp[i] = dp[i-word.length()] && word == s[j:i]
        memset(dp, false, sizeof(dp));
        for(int i=0;i<len;i++){
            for(int j=0;j<size;j++){
                string word = wordDict[j];
                int word_len = (int) word.length();
                if(s[i] == word[word_len - 1] &&
                ((i- word_len + 1) >= 0
                && s.substr(i-word_len+1, word_len)==word)
                && (i-word_len < 0 || dp[i-word_len])){
                    dp[i] = true;
                    break;
                }else{
                    dp[i] = false;
                }
            }
        }
        return dp[len-1];
    }

MaximumProductSubarray

问题描述：给定一个数组，里面可能包含负数。试计算连续子数组乘机的最大值。
分析：
- 首先如何转化成子问题？对于一个数组，我们可以计算nums[:len-1], nums[:len-2]对应的值，这样就可以转化成子问题。
- 如果由子问题构造解？假设说我们已经知道nums[:len-1]里面的最大值了 $Res_{sub}$ ，我们如果计算nums连续乘积的最大值呢？
  - 如果说nums[len]是正的，那很简单，我们只需要返回 $Res_{sub}*nums[len]$ 即可。
  - 如果nums[len]是负的呢？我们直接返回 $Res_{sub}$ 吗？当然不是，如果nums[:len-1]中有负数，那么我们就要计算nums[:len-1]中的最小值。因为负负得正，所有最小值乘以当前这个数字就有可能是正的，也就有可能大于 $Res_{sub}$ 了。
  - 所有由此看来，我们不仅要维护一个最大结果，还要维护一个最小结果。
  - $Res_i = max(nums[i], Max_{i-1}*nums[i], Min_{i-1} * nums[i])$
  - Max_{i} = max(nums[i], Max_{i-1}*nums[i], Min_{i-1} * nums[i])
  - Min_{i} = min(nums[i], Max_{i-1}*nums[i], Min_{i-1} * nums[i])
代码：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int size = int(nums.size());
        int dp_max;
        int dp_min;
        dp_max = nums[0];
        dp_min = nums[0];
        int res = nums[0];
        for(int i=1;i<nums.size();i++){
            int cur_max = max(nums[i], max(dp_max * nums[i], dp_min * nums[i]));
            int cur_min = min(nums[i], min(dp_max * nums[i], dp_min * nums[i]));
            dp_max = cur_max;
            dp_min = cur_min;
            res = max(res, cur_max);
//            cout<<i<<", "<<dp_max<<", "<<dp_min<<endl;
        }
        return res;
    }
};