动态规划：
动态规划是分治思想的延伸，通俗一点来说就是大事化小，小事化无的艺术。
在将大问题化解为小问题的分治过程中，保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接
使用这些结果。
动态规划具备了以下三个特点：
- 把原来的问题分解成了几个相似的子问题。
- 所有的子问题都只需要解决一次。
- 储存子问题的解。
动态规划的本质：
是对问题状态的定义和状态转移方程的定义(状态以及状态之间的递推关系)
动态规划问题一般从以下四个角度考虑：
- 状态定义
- 状态间的转移方程定义
- 状态的初始化
- 返回结果
状态定义的要求：
定义的状态一定要形成递推关系。
适用场景：
最大值/最小值, 可不可行, 是不是，方案个数
1、斐波那契数列（剑指offer）
斐波那契数列的定义：F(n) = F(n -1) + F(n - 2)，(n >= 2,n∈N*)，其中F(1) = 1,F(2) = 1；
动态规划：
- 状态：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;
//申请一个数组，保存自问的解
int* recond = new int[n + 1];
recond[0] = 1;
recond[1] = 1;
for (int i = 2; i <= n; ++i) {
recond[i] = recond[i - 1] + recond[i - 2];
}
return recond[n];
delete[] recond;
}2、变态青蛙跳台阶
一只青蛙一次可以跳上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(0)
- f(n-1) = f(n-2) + f(n-3) + …… +f(0)
- f(n) = 2 * f(n-1)
初始值：
- f(n) = 2 * F(n-1)
返回值：
- f(n)
int jumpFloorII(int number) {
//F(n) = 2 * F(n - 1)
if (number <= 0)
return 0;
int* recond = new int[number + 1];
recond[0] = 0;
recond[1] = 1;
for (int i = 2; i <= number; ++i) {
recond[i] = 2 * recond[i - 1];
}
return recond[number];
delete[] recond;
}3、最大连续子数组和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1）
动态规划：
状态：
- 子状态：长度为1、2……、n的子数组和的最大值
- 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;
int sum = array[0];
int maxsum = array[0];
for (int i = 0; i < array.size();++i) {
sum = (sum > 0) ? sum + array[i] : array[i];
maxsum = (sum < maxsum) ? maxsum : sum;
}
return maxsum;
}4、字符串分割
给定一个字符串和一个词典dict，确定s是否可以根据词典中的词分成一个或多个单词。
比如，给定 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中，只要能找到一个就返回 true，并且从 i + j 到 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()];
}