【leetcode】dp---中等（1）120. 三角形最小路径和_dp迷宫（2）139. 单词拆分_dp序列_长度为状态（3）152. 乘积最大子数组_dp序列积_正负

120、给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。

例如，给定三角形：

 [   [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]]

自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

 dp[i][j] = min(dp[i-1][j], dp[i-1][j-1]) + grid[i]

// dp[i][j]:抵达(i,j)的最小路径和
// 状态转移：1）(i-1,j)下移； 2）(i-1,j-1)下移+右移
// dp[i][j] = min(dp[i-1][j], dp[i-1][j-1]) + grid[i]
class Solution {
public:
    int minimumTotal(vector<vector<int>>& grid) {
        int m = grid.size();
        for(int i = 1; i < m; i++){
            for(int j = 0; j <= i; j++){
                if(j == 0) grid[i][j] += grid[i-1][j];
                else if(j == i) grid[i][j] += grid[i-1][j-1];
                else grid[i][j] += min(grid[i-1][j-1], grid[i-1][j]);
            }
        }
        int ans = 1e6;
        for(int i = 0; i < m; i++) ans = min(ans, grid[m-1][i]);
        return ans;
    }
};

结果：

执行用时：4 ms, 在所有 C++ 提交中击败了99.81% 的用户

内存消耗：8.1 MB, 在所有 C++ 提交中击败了99.29% 的用户

 

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

说明：

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

示例 1：

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以被拆分成 "apple pen apple"。
         注意你可以重复使用字典中的单词。

dp[i]:前i个字符是否可以被成功拆分

 dp[j] == 1 && s1=s.substr(j+1, i-j+1),s1在wordDict中可以被找到。 ======》   dp[i] =1

// dp[i]:前i个字符是否可以被成功拆分
// 状态转移：前j个字符可以被拆分，j+1~i可以被拆分。
// dp[j] == 1 && s1=s.substr(j+1, i-j+1),s1在wordDict中可以被找到。  dp[i] ==1
class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        set<string> st;
        set<int> lenth;
        for(auto &i:wordDict) {
            st.insert(i);
            lenth.insert(i.size());
        }
        vector<int> dp(s.size() + 1, 0);
        dp[0] = 1;
        for(int i = 1; i <= s.size(); i++){
            if(dp[i-1] == 0) continue;
            for(auto &len:lenth ){
                if(i-1+len <= s.size() && st.count(s.substr(i-1, len))) dp[i-1+len] = 1;
            }
        }
        return dp[s.size()] == 1 ? true : false;
    }
};

结果：

执行用时：8 ms, 在所有 C++ 提交中击败了84.56% 的用户

内存消耗：8 MB, 在所有 C++ 提交中击败了78.62% 的用户

 

152、给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

示例 1:

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

 两个dp数组 ： ma[i]: 以第i个位置结尾的序列，最大乘积   mi[i]:以第i个位置结尾的序列，最小乘积

ma[i] = max(nums[i], max(nums[i] * ma[i-1], nums[i] * mi[i-1]));

mi[i] = min(nums[i], min(nums[i] * ma[i-1], nums[i] * mi[i-1]));

// ma[i]: 以第i个位置结尾的序列，最大乘积   mi[i]:以第i个位置结尾的序列，最小乘积
// 状态转移：1）归入前序列；2）独自成为一个序列头
// ma[i] = max(nums[i], max(nums[i] * ma[i-1], nums[i] * mi[i-1]));
// mi[i] = min(nums[i], min(nums[i] * ma[i-1], nums[i] * mi[i-1]));
class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n = nums.size();
        int ans = nums[0];
        vector<int> ma(n), mi(n);
        ma[0] = mi[0] = nums[0];
        for(int i = 1; i < n; i++){
            ma[i] = max(nums[i], max(nums[i] * ma[i-1], nums[i] * mi[i-1]));
            mi[i] = min(nums[i], min(nums[i] * ma[i-1], nums[i] * mi[i-1]));
            ans = max(ans, max(ma[i], mi[i]));
        }
        return ans;
    }
};

结果：

执行用时：4 ms, 在所有 C++ 提交中击败了98.04% 的用户

内存消耗：12 MB, 在所有 C++ 提交中击败了34.86% 的用户