Dynamic Programming -- 动态规划

---

定义

动态规划简称DP问题，是分治思想的延伸，通俗一点来说就是大事化小，小事化无的艺术。

在将大问题化解为小问题的分治过程中，保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接使用这些结果。

特点

动态规划具备了以下三个特点：

1. 把原来的问题分解成了几个相似的子问题。
2. 所有的子问题都只需要解决一次。
3. 储存子问题的解。

本质

动态规划的本质：是对问题状态的定义和状态转移方程的定义。
（状态转移方程：状态之间的递推关系）

动态规划问题一般从以下四个角度考虑：

1. 状态定义
2. 状态间的转移方程定义
3. 状态的初始化
4. 返回结果

• 状态定义的要求：定义的状态一定要形成递推关系。
• 【概括】：三特点四要素两本质
• 适用场景：最大值/最小值, 是否可行, 是不是，方案个数等。

---

样例

Fibonacci

斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……

我们知道他的递推公式是：F(n)=F(n-1)+F(n-2)（n>=2，n∈N*），其中F(1)=1，F(2)=1。所以很容易用递归实现：

int Fibonacci(int n){
	// 初始值
	if (n <= 0){
		return 0;
	}
	if (n == 1 || n == 2) {
		return 1;
	}
	//递推公式：F(n)=F(n-1)+F(n-2)
	return Fibonacci(n - 2) + Fibonacci(n - 1);
}

可以想到斐波那契数列递归求解最大的缺点就是：大量的重复计算。

它的方法时间复杂度为O(2^n)，随着n的增大呈现指数增长，效率不尽人意。而当输入比较大时，还可能导致栈溢出。

如何优化？使用动态规划思想！

【动态规划】解法：
	 状态：F(n)
	 状态递推：F(n) = F(n-1) + F(n-2)
	 初始值：F(1) = F(2) = 1
	 返回结果：F(N)

代码实现：

int Fibonacci(int n){
	// 初始值
	if (n <= 0){
		return 0;
	}
	if (n == 1 || n == 2) {
		return 1;
	}
	
	// 申请一个数组，保存子问题的解，题目要求从第0项开始
	int* record = new int[n + 1];
	record[0] = 0;
	record[1] = 1;
	for (int i = 2; i <= n; i++){
		// F(n)=F(n-1)+F(n-2)
		record[i] = record[i - 1] + record[i - 2];
	}
	
	//返回结果
	return record[n];
	delete[] record;
}

上述解法的时间、空间复杂度均为O(n)，对于递归的时间复杂度O(2^n)有了明显优化。

但其实F(n)只与它相邻的前两项有关，所以没有必要保存所有子问题的解，只需要保存两个子问题的解就可以。

以下方法将空间复杂度降为O(1)

int Fibonacci(int n){
	// 初始值
	if (n <= 0){
		return 0;
	}
	if (n == 1 || n == 2) {
		return 1;
	}
	
	int fn1 = 1;
	int fn2 = 1;
	int result = 0;
	
	for (int i = 3; i <= n; i++){
		// F(n)=F(n-1)+F(n-2)
		result = fn2 + fn1;
		
		// 更新值
		fn1 = fn2;
		fn2 = result;
	}
	return result;
}

变态青蛙跳台阶(Climbing Stairs)

• 例题描述：
  一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

状态：
	子状态：跳上1级，2级，3级，...，n级台阶的跳法数
		f(n)：还剩n个台阶的跳法数
	
状态递推：
	n级台阶，第一步有n种跳法：跳1级、跳2级、到跳n级
	跳1级，剩下n-1级，则剩下跳法是f(n-1)
	跳2级，剩下n-2级，则剩下跳法是f(n-2)
	f(n) = f(n-1)+f(n-2)+...+f(n-n)
	
	f(n) = f(n-1)+f(n-2)+...+f(0)
	f(n-1) = f(n-2)+...+f(0)
	错位相减得：
	f(n) = 2*f(n-1)

初始值：
	f(1) = 1
	f(2) = 2*f(1) = 2
	f(3) = 2*f(2) = 4
	f(4) = 2*f(3) = 8
	所以它是一个等比数列
	f(n) = 2^(n-1)

返回结果：	
	f(n)

代码实现：

int jumpFloorII(int number) {
    if(number <= 0)
        return 0;
        
    int total = 1;
    for(int i = 1;i < number;i++)
        total *= 2;
        
    return total;
}

优化：降低时间复杂度。
上述实现的时间复杂度:O(N)，优化为O(1)的实现：使用移位操作

int jumpFloorII(int number) {
    if(number <= 0)
        return 0;
        
    return 1 << (number-1);
}

连续子数组最大和

• 例题描述：
  HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

状态：
  子状态：长度为1，2，3，...,n的子数组和的最大值
  F(i):长度为i的子数组和的最大值，这种定义不能形成递推关系，舍弃
  F(i):以array[i]为末尾元素的子数组和的最大值
  
状态递推：
  F(i) = max(F(i-1) + array[i]，array[i])
  F(i) = （F(i-1) > 0）? F(i-1) + array[i] : array[i]
  
初始值：F(0) = array[0]

返回结果：
  maxsum：所有F(i)中的最大值
  maxsum = max(maxsum，F(i))

代码实现：

int FindGreatestSumOfSubArray(vector<int> array){
	if (array.empty()){
		return -1;
	}
	
	// F(i)初始化
	int sum = array[0];
	// maxsum初始化
	int maxsum = array[0];
	
	for (int i = 1; i < array.size(); i++){
		// F(i) = max(F(i-1) + array[i]，array[i])
		sum = (sum > 0) ? sum + array[i] : array[i];
		// maxsum = max( maxsum，F(i))
		maxsum = (sum < maxsum) ? maxsum : sum;
	}
	return maxsum;
}

字符串分割(Word Break)

• 例题描述：
  给定一个字符串s和一组单词dict，判断s是否可以用空格分割成一个单词序列，使得单词序列中所有的单词都是dict中的单词（序列可以包含一个或多个单词）。

例如:
给定s=“leetcode”； dict=["leet", "code"].
返回true，因为"leetcode"可以被分割成"leet code".

状态：
  子状态：前1，2，3，...,n个字符能否根据词典中的词被成功分词
  F(i): 前i个字符能否根据词典中的词被成功分词
  
状态递推：
  F(i): true{j < i && F(j) && substr[j+1,i]能在词典中找到} OR false
  在j小于i中，只要能找到一个F(j)为true，并且从j+1到i之间的字符能在词典中找到，则F(i)为true
  
初始值：
  对于初始值无法确定的，可以引入一个不代表实际意义的空状态，作为状态的起始
  空状态的值需要保证状态递推可以正确且顺利的进行
  F(0) = true
  
返回结果：F(n)

代码实现：

bool wordBreak(string s, unordered_set<string> &dict){
	if (s.empty()){
		return false;
	}
	if (dict.empty()){
		return false;
	}
	
	// 获取词典中的单词的最大长度
	int max_length = 0;
	unordered_set<string>::iterator dict_iter= dict.begin();
	for (; dict_iter != dict.end(); dict_iter++){
		if ((*dict_iter).size() > max_length){
			max_length = (*dict_iter).size();
		}
	}
	vector<bool> can_break(s.size() + 1, false);
	// 初始化 F(0) = true
	can_break[0] = true;
	for (int i = 1; i <= s.size(); i++){
		for (int j = i - 1; j >= 0; j--){
			// 如果最小子串长度大于max_length，跳过
			if ((i - j) > max_length)	break;
			
			// F(i): true{j <i && F(j) && substr[j+1,i]能在词典中找到} OR false
			// 第j+1个字符的索引为j
			if (can_break[j] && dict.find(s.substr(j, i - j)) != dict.end()){
				can_break[i] = true;
				break;
			}
		}
	}
	return can_break[s.size()];
}