数据结构学习日志—1.21、1.22、1.23（动态规划）

动态规划

具体来说，动态规划的一般流程就是三步：
暴力的递归解法 -> 带备忘录的递归解法 -> 迭代的动态规划解法。
就思考流程来说，就分为一下几步：
找到状态和选择 -> 明确 dp 数组/函数的定义 -> 寻找状态之间的关系。
参考链接1：
https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/dynamic-programming
动态规划的根本目的是避免重复计算
参考链接2：
https://labuladong.gitbook.io/algo/dong-tai-gui-hua-xi-lie/dong-tai-gui-hua-ji-ben-ji-qiao/dong-tai-gui-hua-xiang-jie-jin-jie

动态规划的三要素：
1.状态转移方程；
2.临界条件
3.枚举状态
这个和递归也非常相似。
动态规划的难点在于如何写出状态转移方程，我们首先需要做到
明确 base case -> 明确「状态」-> 明确「选择」 -> 定义 dp 数组/函数的含义。
套路框架如下：

# 初始化 base case
dp[0][0][...] = base
# 进行状态转移
for 状态1 in 状态1的所有取值：
    for 状态2 in 状态2的所有取值：
        for ...
            dp[状态1][状态2][...] = 求最值(选择1，选择2...)

题目1.：最佳买卖股票时机含冷冻期

这道题可以采用动态规划的方式来解决，之前的买卖股票的最佳时机II，设置了两种状态
即：dp[i][0]为今天持有现金；dp[i][1]为今天持有股票。
这道题的状态可以增加为三个

这里的「处于冷冻期」指的是在第 ii 天结束之后的状态。也就是说：如果第 ii 天结束之后处于冷冻期，那么第 i+1i+1 天无法买入股票。

详细请看
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/solution/zui-jia-mai-mai-gu-piao-shi-ji-han-leng-dong-qi-4/

代码如下：第二种方法优化了空间，即采用滚动数组的方式，使用三个变量代替二维数组，实现优化

int maxProfit(vector<int>& prices) {
	if (prices.empty())	return 0;
	//定义状态变量数组
	int n = prices.size();
	vector<vector<int>>dp(n, vector<int>(3));
	//第0天
	dp[0][0] = -prices[0];
	dp[0][1] = 0;
	dp[0][2] = 0;
	for (int i = 1; i < n; i++) {
		dp[i][0] = max(dp[i - 1][0], dp[i - 1][2] - prices[i]);
		dp[i][1] = dp[i][0] + prices[i];
		dp[i][2] = max(dp[i - 1][2], dp[i - 1][1]);
	}
	//最大的理论应该在dp[n-1][1]和dp[n-1][2]之间
	return max(dp[n - 1][1], dp[n - 1][2]);

}

//空间优化，使用变量储存dp[i][0]等三个变量，这样就可以将空间复杂度从O(n)降低到O(1)
int maxProfit2(vector<int>& prices) {
	if (prices.empty())	return 0;
	//定义状态变量数组
	int n = prices.size();
	//第0天
	int f0 = -prices[0];
	int f1 = 0;
	int f2 = 0;
	for (int i = 1; i < n; i++) {
		int new_f0 = max(f0, f2 - prices[i]);
		int new_f1 = f0 + prices[i];
		int new_f2 = max(f2,f1);
		f0 = new_f0;
		f1 = new_f1;
		f2 = new_f2;
	}
	//最大的理论应该在dp[n-1][1]和dp[n-1][2]之间
	return max(f1,f2);

}

sort函数从大到小排序可以使用反向迭代器

sort(coins.rbegin(),coins.rend());

题目2：零钱兑换

首先对这个问题进行分析，对待问题我们要有减而治之和分而治之的思想，这也是递归和动态规划中比较重要的思维，就是最优子结构，我们想在考试中取得好成绩，我们就需要在语文、数学、英语等科目中取得好成绩，就是这个道理。那么对于这道题而言，按照示例1，如果想求amount=11，根据面值[1,2,5]，就可以将问题转换为求集合amount=10 、 9 、6的最少硬币。

状态方程：

这道题通过画图的方式也可以很快的理清递归思路
在这里插入图片描述
下面是两种解法的代码：
方法1.递归法+记忆法

//方法1：暴力递归法+哈希表记忆法，避免重复计算
int coinChange2(vector<int>& coins, int amount) {
	if (amount == 0)	return 0;
	if (amount < 0)	return -1;
	//定义一个极大值
	int res = 2 * pow(10, 4);
	//递归
	for (auto &coin : coins) {
		//如果子问题返回-1（不能凑成金额），就将其忽略
		//使用amount逐个减去coin值，就可以把这个问题分成若干子问题
		//比如amount=11，coins=[1,2,5],那么就变成了求coinChage(10)、coinChage(9)、coinChage(6)的值，并取其最小值
		int nv = amount - coin;
		if (map.find(nv)==map.end())
			map[nv] = coinChange2(coins, nv);
		if (map[nv] == -1) continue;
		res = min(res, 1 + map[nv]);
	}
	if (res == 2 * pow(10, 4))
		return -1;
	else
		return res;
}

方法2.动态规划

int coinChange3(vector<int>& coins, int amount) {
	//定义状态数组
	vector<int>dp(amount + 1, amount + 1);
	//base case
	dp[0] = 0;
	//外层循环遍历所有状态的可能
	for (int i = 0; i < dp.size(); i++) {
		//内层for循环求所有选择
		for (int coin : coins) {
			//如果子问题误解，就跳过
			if (i - coin < 0)	continue;
			dp[i] = min(dp[i], dp[i - coin] + 1);//状态方程
		}
	}
	return dp[amount] == amount + 1 ? -1 : dp[amount];
}

int转string的方法：to_string函数

题目3：解码方法

方法一：递归加记忆法
自己做的这个方法很麻烦，还用到了int 转string char转string等
int 转string：to_string函数
string转int：stoi函数
char转string：string a(1，b)
substr(a,2)函数返回从a开始长度为2的字符串

class Solution {
public:
	unordered_map<string, int>map;
	unordered_map<string, int>hash;
	void init(unordered_map<string, int>&map) {
		for (int i = 1; i < 27; i++) {
			map[to_string(i)] = 0;
		}
	}

	string getLast2( string s) {
		return s.substr(s.size() - 2, 2);
	}
	int numDecodings(string s) {
		init(map);
		return dp(s, "", true);
	}
	int dp(string s, string s_sub,bool is_first) {
		//这个必须要作为第一项判断，防止s_sub不合法的情况下 仍返回对应的hash[s]
		if (!is_first) {
			if (map.find(s_sub) == map.end())
			{
				return 0;
			}
		}
		if (hash.find(s) != hash.end())
			return hash[s];
		if (s.size() == 1 && map.find(s) != map.end())
			return 1;
		else if(s.size() == 1&& map.find(s) == map.end())
			return 0;
		if (s.empty()) {
			if (is_first)
				return 0;
			else
				return 1;
		}
		string s_copy = s;
		string s2 = s;
		//char对象转为string
		string s_one(1,s.back());
		s.pop_back();
		int sum1 = 0,sum2=0;
		//第一种递归情况，只取出一个字符
		sum1 += dp(s, s_one,false);
		if (s2.size() >= 2) {
			string s_two = getLast2(s2);
			s2.pop_back();
			s2.pop_back();
			//第二种递归情况，取出两个字符
			sum2 += dp(s2, s_two,false);
		}
		return hash[s_copy]=sum1 + sum2;
	}
};

方法二：动态规划

代码：

在这里插入代码片

int numDecodings2(string s) {
		size_t n = s.size();
		if (n == 0||s[0]=='0')	return 0;
		//创建动态规划数组
		vector<int>vec(n + 1, 0);
		//对于前两项
		vec[0] = 1;//表示dp[-1]
		vec[1] = 1;//表示dp[0]
		for (int i = 1; i < n; i++) {
			if (s[i] == '0') {
				if (s[i - 1] == '1' || s[i - 1] =='2')
					vec[i + 1] = vec[i-1];
				else
					return 0;
			}
			else if (s[i - 1] == '1' || (s[i - 1] == '2'&&s[i] >= '1'&&s[i] <= '6'))
				vec[i + 1] = vec[i] + vec[i - 1];
			else
				//s[i - 1]为3-9
				vec[i + 1] = vec[i];
		}
		return vec[n];
	}

滚动数组减少空间复杂度

int numDecodings3(string s) {
		size_t n = s.size();
		if (n == 0 || s[0] == '0')	return 0;
		int pre = 1;//表示dp[-1]
		int curr = 1;//表示dp[0]
		int next = 0;//表示dp[i]
		for (int i = 1; i < n; i++) {
			if (s[i] == '0') {
				if (s[i - 1] == '1' || s[i - 1] == '2')
					next = pre;
				else
					return 0;
			}
			else if (s[i - 1] == '1' || (s[i - 1] == '2'&&s[i] >= '1'&&s[i] <= '6'))
				next = curr + pre;
			else
				//s[i - 1]为3-9
				next = curr;
			pre = curr;
			curr = next;

		}
		return curr;
	}

题目4：单词拆分

首先通过分析，如果要”leetcode“可以拆分，那么说明leetcode-某一个word后仍然可以拆分（或已经等于某一个单词），所以这个问题是可以逐渐拆分成子问题的，这种情况下我们就可以通过动态规划来解决。
 1.明确状态i：i就代表当前的字符串下标；
 2.状态数组的含义：dp[i]表示由0-i组成的字符串能否可以用字典中的单词表示。

详细题解：
https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/medium/139.word-break
代码：
时间复杂度O(n^2)，空间复杂度O(n)

bool wordBreak(string s, vector<string>& wordDict) {
	//创建集合
	unordered_set<string> wordList;
	for (auto word : wordDict) {
		//将单词插入集合中
		wordList.insert(word);
	}
	int n = s.size();
	//创建状态数组
	vector<bool>dp(n+1, false);
	dp[0] = true;//表示第一个引号
	//通过两重循环来逐次遍历s中是否可以拆分成各个word
	for (int i = 1; i < n + 1; i++) {
		for (int j = 0; j < i; j++) {
			//根据i和j，选出这个区间内的字符串，检查是否是wordList中的一员
			//dp[i]表示的是，前i个字符所组成的字符串是否能由wordList中的单词表示
			string s_sub = s.substr(j, i - j);
			if (dp[j] && wordList.count(s_sub)) {
				dp[i] = true;
				break;
			}
		}
	}
	return dp[n];
}

题目5：按摩师

这道题和那个买股票含冷冻期一个道理，甚至更简单一点，就是分为两种状态，今天去服务和今天不去服务；那么状态方程就可以比较容易地写出来了，代码如下：
今天去服务的收益应该是 昨天未去服务的总值+今天的增值
今天不去服务的收益应该取max{昨天未去服务的总值，昨天去服务总值}

    int massage(vector<int>& nums) {
        int n=nums.size();
        vector<vector<int>>dp(n+1,vector<int>(2));
        //舒适化base case
        dp[0][0]=0;
        dp[0][1]=0;
        for(int i=1;i<=n;i++){
            //状态方程
            //dp[i][0]表示今天去服务的收益
            //dp[i][1]表示今天不去服务的收益
            dp[i][0]=dp[i-1][1]+nums[i-1];
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]);
        }
        return max(dp[n][0],dp[n][1]);
    }