动态规划
Posted 李憨憨_
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了动态规划相关的知识，希望对你有一定的参考价值。
动态规划
文章目录
Dynamic Programming
DP定义：
动态规划是分治思想的延伸，通俗一点来说就是大事化小，小事化无的艺术。
在将大问题化解为小问题的分治过程中，保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接使用这些结果。
动态规划的三个特点
- 把原来的问题分解成了几个相似的子问题。
- 所有的子问题都只需要解决一次。
- 存储子问题的解
动态规划的本质，是对问题状态的定义和状态转移方程的定义（状态以及状态之间的地推关系）
动态规划问题一般从以下四个角度考虑：
- 状态定义
- 状态间的转移方程定义
- 状态的初始化
- 返回结果
状态定义的要求：定义的状态一定要形成递推关系。
例一：fibonacci
方法一：递归
如果n比较小的话，我们就可以采用递归的方法
class Solution
public:
int Fibonacci(int n)
if (n == 0)
return 0;
if (n == 1 || n == 2)
return 1;
return Fibonacci(n - 1) + Fibonacci(n - 2);
;
但是这种方法并不可取，因为如果n取一个很大的值的话，就会出现栈溢出的现象
此时的空间复杂度是一个O(n)，时间复杂度是一个O(2^n)
方法二：动态规划
重点在于找到其状态以及转移方程
问题：数列第n项的值
状态F(i)：数列第i项的值
转移方程：
F(i): F(i - 1) + F(i - 2);
初始状态：
F(0) = 0;
F(1) = 1;
返回值：
F(n)
class Solution
public:
int Fibonacci(int n)
vector<int> F(n + 1, 0);
//初始化 F(0) = 0; F(1) = 1;
F[1] = 1;
for(int i = 2; i <= n; ++i)
F[i] = F[i - 1] + F[i - 2];
return F[n];
;
相对于递归来说，此时的时间复杂度为O(n)，空间复杂度还是一个O(n);
优化：
class Solution
public:
int Fibonacci(int n)
//f(n - 2)
int fn2 = 0;
//f(n - 1)
int fn1 = 1;
int fn;
if(n <= 1)
return n;
for(int i = 2; i <= n; ++i)
fn = fn1 + fn2;
fn2 = fn1;
fn1 = fn;
return fn;
;
采用的是一个空间换时间的概念，此时的空间复杂度就为O(1)，空间复杂度就为O(n)；
例二：青蛙跳台阶问题
方法一：动态规划
问题：跳上n级台阶的方法个数
状态F(i)：跳上第i级台阶的方法个数
转移方程：
解析：
就F(4)而言
我先站在第一级台阶上（至于我是怎么站在第一级台阶上的，我不关心），然后再条三级台阶，就可以到达第四级台阶。
我先站在第二级台阶上（至于我是怎么站在第二级台阶上的，我不关心），然后再条两级台阶，就可以到达第四级台阶。
我先站在第三级台阶上（至于我是怎么站在第三级台阶上的，我不关心），然后再条一级台阶，就可以到达第四级台阶。
总结：
我如果选择最后跳一级台阶，我就应该站在 i - 1 级台阶之上，我如果选择最后跳两级台阶，我就应该站在 i - 2 级台阶之上，以此类推，我如果最后选择跳 i 级台阶，我就应该站在第0级台阶之上；所以：
F(i)：F(i - 1) + F(i - 2) + … + F(0)
以此类推：
F(i - 1)：F(i - 2) + F(i - 3) + … + F(0)
因此：
F(i)：F(i - 1) + F(i - 1) = 2 * F(i - 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)
class Solution
public:
int jumpFloorII(int number)
if(number == 0)
return 0;
int ret = 1;
for(int i = 2; i <= number; ++i)
ret *= 2;
return ret;
;
优化：当然我们也可以用移位来进行操作，降低时间复杂度
class Solution
public:
int jumpFloorII(int number)
if(number == 0)
return 0;
return 1 << (number - 1);
;
问题扩展：
此题看似复杂，通过抽象和归纳，可以找出问题的内在规律定义问题的状态，以及状态间的递推关系，找到问题的答案
扩展1：
上述问题为变态青蛙跳台阶，太疯狂，这只青蛙像是吃了大力丸身上充满了无穷的力量。现在让它变成一个正常的青蛙，限制它一次只能跳1阶或者2阶，现在该如何解答
扩展2：牛客网上另一个题目：矩形覆盖
我们可以用2 * 1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2 * 1的小矩形无重叠地覆盖一个2 * n的大矩形，总共有多少种方法？
例三：最大连续子数组和
方法：动态规划
问题：数组的最大连续和
子问题：局部元素构成的数组，它的最大连续和
状态F(i)：以第i个元素结尾的最大连续子序列和
转移方程：
F(i) = max(F(i - 1) + a[i], a[i])
初始状态：
F(0) = a[0]
返回值：
max(F(i))
class Solution
public:
int FindGreatestSumOfSubArray(vector<int> array)
if(array.empty())
return 0;
//F(0) = a[0]
vector<int> maxSum(array);
for(int i = 1; i < array.size(); ++i)
//F(i) = max(F(i - 1) + a[i], a[i])
maxSum[i] = max(maxSum[i - 1] + array[i], array[i]);
//max(F(i))
int ret = maxSum[0];
for(int i = 1; i < maxSum.size(); ++i)
ret = max(ret, maxSum[i]);
return ret;
;
例四：字符串分割
问题：单词是否可以成功分割
子问题：单词前几个字符是否可以成功分割
状态F(i)：单词前i个字符是否可以成功分割
转移方程：
F(i)：j < i && F(j) && [j + 1, i]是否可以在词典中找到
判断前i个字符整体是否可以在词典中找到
返回结果：
F(s.length())
class Solution
public:
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): truej <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()];
;
以上是关于动态规划的主要内容，如果未能解决你的问题，请参考以下文章