算法：动态规划（二）

- 分割字符串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。

class Solution {
private:
    vector<string> tempanswer;
    vector<vector<string>> result;

public:
    vector<vector<string>> partition(string s) {
        int n = s.size();
        vector<vector<bool>>isTenetdp(n, vector<bool>(n, false));
        vector<vector<int>>dp(n, vector<int>(n, 0));
        for(int i = 0; i < n; i++){
            isTenetdp[i][i] = true;
            dp[i][i] = 1;
            if(i < n - 1 && s[i] == s[i + 1])
                isTenetdp[i][i + 1] = true;
        }

    }

    
};

经验：
1、第一次审题的时候出现了误差，以为是返回所有的分割方法数
2、DFS+DP的想法很独特，确实如果要返回所有的分割方法的话确实是应该使用DFS，而DP主要是为了降低判断回文串的时间复杂度 。

- 单词拆分

给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。
说明：
拆分时可以重复使用字典中的单词。
你可以假设字典中没有重复的单词。

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        int length = s.size();
        vector<bool>dp(length + 1, false);
        dp[0] = true;
            
        for(int i = 1; i  <= length; i++){
            for(int j = 0; j <= i; j++){
                if(dp[j] && isSplited(s.substr(j, i - j), wordDict)){
                    dp[i] = true;
                    break;
                }
            }                 
        } 
        return dp[length];
    }

    bool isSplited(string s, vector<string>& wordDict){
        int n = wordDict.size();
        for(int i = 0; i < n; i++)
            if(wordDict[i] == s)
                return true;
        return false;
    }
};

经验：
1、又是DP三分钟，调边界一年的问题
2、注意Python的嵌套条件语句习惯请不要带到C++里，说多了都是泪。。习惯所有控制语句都加上括号应该可以有效避免这个问题，虽然看上去代码行数可能会变长。

• 乘积最大子数组

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

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n = nums.size();
        vector<vector<long>>dp(n, vector<long>(2));
        for(int i = 0; i < n; i++){
            dp[i][0] = dp[i][1] = nums[i];
        }

        for(int i = 1; i < n; i++){
            long temp = nums[i];
            long a = temp * dp[i - 1][0];
            long b = temp * dp[i - 1][1];
            dp[i][0] = max(a, max(b, temp));
            dp[i][1] = min(a, min(b, temp));
        }

        long result = LONG_MIN;
        for(int i = 0; i < n; i++)
            if(dp[i][0] > result)
                result = dp[i][0];
        return result;
    }

};

经验：
1、第一次写出这种shape是<n, 2>的DP题，值得纪念。
2、algorithm包中的max函数只能比较同样类型的数。不能int和long互相比。
3、最大值

T Max(T x, T y, T z)
{
	return x > y ? (x > z ? x : z) : (y > z ? y : z);
}

- 打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

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

经验：
1、水题，虽然最开始错误理解成了是奇数和偶数

- 打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

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

    int rob_origin(vector<int>& nums) {
        int n = nums.size();
        if(n == 1)
            return nums[0];
        else if(n == 0)
            return 0;
        else if(n == 2)
            return max(nums[0], nums[1]);
        
        vector<int>dp(n);
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for(int i = 2; i < n; i++){
            dp[i] = max(dp[i - 1], nums[i] + dp[i - 2]);
        }
        return dp[n - 1];
    }
};

经验：
1、给想复杂了，，<n, 2>的DP上头了然后一直没有想到直接拆成两种不同的数列分别求一遍然后取大的那个即可。。