刷题 动态规划

动态规划法：
* 动态规划求解问题的四个特征：
①求一个问题的最优解；
②整体的问题的最优解是依赖于各个子问题的最优解；
③小问题之间还有相互重叠的更小的子问题；
④从上往下分析问题，从下往上求解问题；

1. 剪绳子（剑指offer 14 or leetcode 343 整数拆分）

题目： 给你一根长度为n绳子，请把绳子剪成m段（m、n都是整数，n>1并且m>1）。每段的绳子的长度记为k[0]、k[1]、……、k[m]。k[0] * k[1]*…*k[m]可能的最大乘积是多少？例如当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到最大的乘积18。

给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。
1.动态规划
解题思路：

1. 当n小于等于3时，n为1乘积为0，n为2 （1乘以1）乘积为1，n为3（1乘以2）乘积为2。
2. 当n大于3时，初始化动态规划的初始条件，n为1 2 3 时不切割的值最大，故dp[0] dp[1] dp[2] dp[3]做为初始条件。
3. 循环，从下往上求解问题，从n=4开始，每次将n拆分为两部分的乘积，从1到n/2即可，之后的情况均已经计算过，当值大于max时，更新max，内循环结束 dp[n]的值就等于max。
4. 最终返回dp[n]即为最终的结果。

class Solution {
public:
    int integerBreak(int n) {
        if(n<2)
            return 0;
        if(n==2)
            return 1;
        if(n==3)
            return 2;
        vector<int> dp(n+1);
        dp[0]=0;
        dp[1]=1;
        dp[2]=2;
        dp[3]=3;

        int max;
        for(int len=4;len<=n;len++)
        {
            max=0;
            for(int i=1;i<=len/2;i++)
            {
                int tmp=dp[i]*dp[len-i];
                if(tmp>max)
                    max=tmp;
            }
            dp[len]=max;
        }
        return dp[n];
    }
};

2.贪心算法
解题思路：

1. n小于等于3时，情况类似。
2. 当n>=5时，尽可能多的拆分为3，当最后剩下长度为1时，退一步得4，拆分为2乘以2。 当最后剩下为2时，乘以最后的2即可。
   证明：（3(n-3)>=2(n-2)>n） 故应该尽可能多的拆分为3
3. 当n=4时，拆分为3和1，退一步，拆分为2乘以2.

class Solution {
public:
    int integerBreak(int n) {
        if(n<2)
            return 0;
        if(n==2)
            return 1;
        if(n==3)
            return 2;
        int times_3=n/3;
        if(n-times_3*3==1)
            times_3--;
        int times_2=(n-times_3*3)/2;
        
        return (int)(pow(3,times_3))*(int)(pow(2,times_2));
    }
};

2. 连续子数组的最大和

题目描述：
输入一个整数数组，数组里有正数也有负数。数组中的一个或多个连续整数组成一个子数组。求所有子数组的和的最大值，时间复杂度O(n)。
解题思路：

1. 每一个状态的最优解都依赖于子问题的解，采用动态规划求解。
2. 动态规划公式如下：当该元素之前的最大和小于0，包含该元素的最大和为该元素值，否则，加上之前的最大和。
   
3. 需要一个最大值中间量记录每次的最大值，防止出现最后几个元素均为负值但和大于0的情况。

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        if(array.size()==0)
            return 0;
        int n=array.size();
        vector<int> dp(n+1);
        dp[0]=0;
        int max=array[0];
        for(int i=0;i<n;i++)
        {
            if(dp[i]>0)
            {
                dp[i+1]=dp[i]+array[i];
            }
            else
            {
                dp[i+1]=array[i];
            }
            if(dp[i+1]>max)
                max=dp[i+1];
        }
        return max;
    }
};

3. 单词拆分

解法一：回溯法（记忆化存储） 时间复杂度O(n^2) 空间复杂度O(n)

1. 若index到达字符串结尾，表示前面位置的字符串可以拆分为在字典中的字符串组合，返回true。
2. 若下次搜索到index位置为-1，直接返回false（记忆化存储，剪枝，降低时间复杂度）。
3. 从字符串s的起始位置出发，搜索当前位置index开始的字符串是否出现在字典中，当遍历到end位置，发现substr(index,end-index)在字典中，则返回true，继续从end+1的位置重复上述操作；否则，将当前位置index的flag置-1，表示当前位置开始无法在字典中找到对应字符串（记忆化），返回false。

class Solution {
public:
    bool word_break_memory(string s,vector<string>& wordDict,int index,vector<int>& flag)
    {
        if(index>=s.size()) return true;       //遍历到字符串结尾，表示之前位置均可拆分为字典中元素，返回true
        if(flag[index]==-1) return false;      //记忆化存储，看到-1表示当前位置不满足条件，剪枝
        for(int end=index+1;end<=s.size();end++){
            if(count(wordDict.begin(),wordDict.end(),s.substr(index,end-index))//index到end位置的字符串在字典中
                && word_break_memory(s,wordDict,end,flag) )  //继续从end到字符串末尾递归调用
                    return true;     //若index到s.size()位置均可以拆分为字典中的元素，则返回true
        }
        flag[index]=-1;      //若index位置开始不能全部拆分为字典中的元素，返回false并置当前位置为-1
        return false;
    }
    
    bool wordBreak(string s, vector<string>& wordDict) {
        if(s.size()==0 || wordDict.size()==0) return false;
        int n=s.size();
        vector<int> flag(n,0);
        return word_break_memory(s,wordDict,0,flag);   //递归调用
    }
};

解法二：动态规划 时间复杂度O(n^2) 空间复杂度O(n)

1. 建立dp数组，dp[i]表示从0到第i个位置的所有单词均可以拆分为字典中存在的元素。初始化dp[0]为1，因为空字符串包含在字典中。
2. 遍历字符串，当j到i的字符串存在在字典中且dp[j]=1，表示i之前的字符串均可拆分，故dp[i]=1，break。
3. 最终返回dp[n]即可知道0到n位置的字符串，也就是整个字符串是否可拆分为字典中的元素组合。

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