回溯的方法超时

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
    //深度优先搜索
    int n=wordDict.size();
    
    bool res=false;
    string str="";
    res=dfs(str,s,wordDict);

    return res;
    }

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

};

方法二：动态规划

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
    vector<bool> dp(s.size()+1,false);
    dp[0]=true;

    for(int i=1;i<=s.size();++i){
        for(auto word:wordDict){
            int sz=word.size();
                              //复制从i-sz处的位置往后sz个字符串
            if(i-sz>=0&&s.substr(i-sz,sz)==word){
                dp[i]=dp[i]||dp[i-sz];
            }
        }
    }
    return dp[s.size()];
    }
};

---

背包问题是一类经典的动态规划问题。

背包问题：
最基本的背包问题就是：一共有N件物品，第i件物品的重量为w[i]，价值为v[i]。在总重量不超过背包承载w的情况下，能够装入背包的最大价值是多少。

完全背包问题：
完全背包问题就是每种物品可以有无限多个。

背包问题和完全背包问题的主要区别就是物品是否可以重复选取。

背包问题具备的特征：
是否可以根据一个target（直接给出或间接给出），target可以是数字也可以字符串，再给定一个数组arrs，问：能否用arrs中的元素做各种排列组合得到target。

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum=0;
        for(int i=0;i<nums.size();++i){
            sum+=nums[i];
        }
        if(sum%2==1) return false;

        int target=sum/2;

        vector<bool> dp(target+1,false);
        dp[0]=true;

        for(auto num:nums){
        //有没有和为i的组合
            for(int i=target;i-num>=0;--i){
                dp[i]=dp[i]||dp[i-num];
            }
        }
        return dp[target];
    }
};

---

解题思路：
假设元素中加正号的元素相加为x，加负号的元素相加为y，x、y均大于0.
则target=x-y;
sum=x+y；
那么2x=target+sum；
也就是说，只要数组中找到若干元素和为x就是一个方法，那么只要找到有多少种方法就可以了。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum=0;
        for(int num:nums) sum+=num;

        //target=x-y
        //sum=x+y
        int two_x=target+sum;
        if(two_x%2==1)return 0;

        int x=two_x/2;
        
        //dp[i]代表前面加+元素相加和为i的方法数
        vector<int>dp(x+1,0);
        dp[0]=1;

        for(int num:nums){
            for(int i=x;i-num>=0;--i){
                dp[i]+=dp[i-num];
            }
        }

        return dp[x];
    }
};

---

class Solution {
public:
    int numSquares(int n) {
        vector<int>dp(n+1,INT_MAX);

        dp[0]=0;

        for(int num=1;num<=sqrt(n);++num){
            for(int i=0;i<=n;++i){
                if(i-num*num>=0){
                    dp[i]=min(dp[i],dp[i-num*num]+1);
                }
            }
        }
        
        return dp[n];
    }
};

---

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {

        vector<int>dp(amount+1,INT_MAX-1);
        dp[0]=0;

        for(auto coin:coins){
            for(int i=0;i<=amount;++i){
                if(i-coin>=0){
                    dp[i]=min(dp[i],dp[i-coin]+1);
                }
            }
        }

        return dp[amount]==INT_MAX-1?-1:dp[amount];
    }
};

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int>dp(target+1,0);
        dp[0]=1;

       for(int i=1;i<=target;++i){
           for(auto num:nums){
               if(i-num>=0&&dp[i-num]<=INT_MAX-dp[i]){
                   dp[i]+=dp[i-num];
               }
           }
       }

        return dp[target];
    }
};

总结：

背包问题：
外层用选择池，内层用target（从大到小）

不考虑排序的背包问题：
外层用选择池，内层用target（从小到大）

考虑排序的完全背包问题：
外层用target，内层用选择池