【算法训练记录——Day44】

1.leetcode322_零钱兑换

思路：最少硬币数量；硬币不同面额；硬币重复使用；硬币组合——完全背包
dp[j]表示 总金额为 j 的最少硬币个数是 dp[j]
若当前已有coins[i],凑够金币只需 凑j-coins[i]总金额即可，然后加上当前硬币。即：dp[j] = dp[j-coins[i]] + 1; 然后遍历硬币，选择最少的个数；

    int coinChange(vector<int>& coins, int amount) {
		vector<int> dp(amount+1, INT_MAX);
		dp[0] = 0;
		for(int i = 0; i < coins.size(); i++) {
			for(int j = coins[i]; j <= amount; j++) {
				if(dp[j-coins[i]] < INT_MAX - 1) {
					dp[j] = min(dp[j], dp[j-coins[i]] + 1);	
				}
			}	
		}
		
		return dp[amount] == INT_MAX ? -1 : dp[amount];
	}

这里因为要选择最小值，所以直接全部初始化为INT_MAX;但是凑足总金额为0所需钱币的个数一定是0，那么dp[0] = 0;

2.leetcode279_完全平方数

思路：如何转换思路。 和为n的完全平方数的最小数量 即 dp[n] = min({dp[n-i*i]});

	int numSquares(int n) {
        vector<int> dp(n + 1, INT_MAX);
        
        dp[0] = 0;

        for(int i = 1; i <= n; i++)
            for(int j = i*i; j <= n; j++) {
                dp[j] = min(dp[j-i*i] + 1, dp[j]);
            }
        
        return dp[n];
    }

3.leetcode139_单词拆分

思路：方法太多不想看了。。。

1. 一个一个来吧，先试试经典回溯

    double times; // 用于计算函数效率

	bool backtracking(const string& s, const vector<string>& wordDict, string str) {
        times++;
        if(s.size() == str.size() && s.compare(str) == 0) {
            return true;
        } else if(s.size() <= str.size()) {
            return false;
        }

        for(int i = 0; i < wordDict.size(); i++) {
            if(backtracking(s, wordDict, str+wordDict[i]) == true)
                return true;
        }

        return false;
    }
    bool wordBreak(string s, vector<string>& wordDict) {
        bool res = backtracking(s, wordDict, "");
        cout << times;
        return res;
    }

测试数据：

	s = "catsandog"
	wordDict = ["cats","dog","sand","and","cat"]

结局显而易见——超时

2. 改良版，如何改良是个问题呀，看了眼题解大概意思说是把之前已经遍历过的值保存一下，如果出现就不用继续遍历了；
   这是什么意思？没理解，先看下自己怎么改
   1. for循环中的 backtracking() 执行完 res == true 后，如果没到边界，还会继续执行，因此，加上 if(res == true) return; 那干脆给函数带上返回值呗，不然还要多用一个 res。——试了一下，还是超时 —— times：156
   2. 分析比较办法，每次都等字符串长度相等时才比较，其实只要刚开始不一样，就可以return 了。 —— times：26
   3. 好好好，还是不行。黔驴技穷了，看题解吧
   4. 看了下用例，大概明白了，如果每次递归完结果不符合，我们回溯以后看下一个是否符合，但是如果回溯后的 str + 下一个字符串 == 回溯前的str + 当前字符串，这样虽然两次的结果是一致的，但会产生重复计算，所以题解采用了 记忆化递归的方式，保存每次递归完成的值，代表以当前元素结尾的str无论如何拼接wordDict中的值，都无法组成s；那么我们每次递归前，只需判断下以当前str结尾的是不是已经尝试过了，如果已经尝试过，那么就不需要尝试了，直接返回false;

	double times;
    vector<bool> memory;
public:
    bool backtracking(const string& s, const vector<string>& wordDict, string str) {
        // cout << str << " ";
        times++;

        if(str.compare(s.substr(0, str.size())) != 0) {
            return false;
        }

        if(s.size() == str.size() && s.compare(str) == 0) {
            return true;
        } else if(str.size() >= s.size()) {
            return false;
        }

        if (memory[str.size()] != true) return memory[str.size()];

        for(int i = 0; i < wordDict.size(); i++) {
            int res = backtracking(s, wordDict, str + wordDict[i]);
            if(res == true) return true;
        }

        memory[str.size()] = false;
        return false;
    }
    bool wordBreak(string s, vector<string>& wordDict) {
        memory.assign(s.size(), true);
        bool res = backtracking(s, wordDict, "");
        cout << times;
        return res;
    }

过了！！！题解跟我的思路差别不大
3. 动态规划
把问题转换成背包
单词就是物品，字符串s就是背包，单词能否组成字符串s，就是问物品能不能把背包装满。
单词可重复，完全背包，但是abcd只能由ab cd构成不能由cd ab构成，有顺序，排列问题；
综上所述：完全背包排列问题，外层背包容量，内层物品
问题难点在于dp怎么推导：
dp[i] : 字符串长度为i的话，dp[i]为true，表示可以拆分为一个或多个在字典中出现的单词。
如果确定dp[j] 是true，且 [j, i] 这个区间的子串出现在字典里，那么dp[i]一定是true。（j < i ）。

所以递推公式是 if([j, i] 这个区间的子串出现在字典里 && dp[j]是true) 那么 dp[i] = true。

	bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordSet(wordDict.begin(), wordDict.end());
        vector<bool> dp(s.size() + 1, false);

        for(int j = 1; j < s.size(); j++) {
            for(int i = 0; i < j; i++) {
                string tmp = s.substr(i, j - i);
                if(wordSet.find(tmp) != wordSet.end() && dp[j] == true) {
                    dp[i] = true;
                }
            }
        }
        return dp[s.size()];
    }