动态规划思想以及常见应用

一动态规划的基本思想以及和贪婪算法、分治法的比较

动态规划的基本思想：将复杂问题进行分解，通过求解小规模子问题反推出原问题的结果。动态规划适合求解多阶段决策问题的最优解（可以简单理解为有状态转换的阶段性问题）。这些问题必须满足最优化原理和子问题的无后向性。

最优化原理：不管之前的决策是否最优，但是一定要保证从现在开始的决策是在之前决策基础上的最优决策。

无后向性原理：当各个子阶段的子问题确定以后，对于某个特定阶段的子问题来说，它之前的各个阶段的子问题的决策只影响当前阶段的决策，而对该阶段之后的决策不产生影响。即每个阶段的决策只受之前决策的影响，不影响之后各阶段的决策。

动态规划与贪婪算法以及分治法的比较：

三者都需要对原问题进行分解，分解为需要求解的子问题。分治法求解的子问题是独立的，每个问题的求解模式一样，分别求解再合并就是原问题的解。而贪婪算法只考虑当前状态，并依据贪婪法则取得局部最优解，直到扩展到原来的问题。动态规划的子问题需要满足最优化原理和无后向性原理。

解决动态规划问题的关键是找到状态转换方程。下面介绍一些常见的应用：

一最长公共子序列

问题：对两个子序列S和T，求解S和T最大公共子序列的长度。

例如 S：ABCDEF；T：ACDF。则最大子序列为ACDF。

分析：假设a[i][j]表示S中下标[0,i]和T中下标[0,j]之间序列的最大公共子序列。分析可知：

代码如下：

int maxCommonSubsequence(const string& s1, const string& s2)
{vector<vector<int>> a(s1.size() + 1, vector<int>(s2.size() + 1, 0));for (int i = 1; i <= s1.size(); i++){for (int j = 1; j <=s2.size(); j++){if (s1[i - 1] == s2[j - 1]){a[i][j] = 1 + a[i - 1][j - 1];}else{a[i][j] = max(a[i-1][j],a[i][j-1]);}}}return a[s1.size()][s2.size()];
}

假如对上面的最长子序列加一个限制，改为最长连续公共子序列。又该如何求解呢？

代码如下：

int maxConsecutiveSubsequence(const string& s1, const string& s2)
{vector<vector<int>> a(s1.size() + 1, vector<int>(s2.size() + 1, 0));int res = 0;for (int i = 1; i <= s1.size(); i++){for (int j = 1; j <=s2.size(); j++){if (s1[i - 1] == s2[j - 1]){a[i][j] = 1 + a[i - 1][j - 1];res = max(res, a[i][j]);}else{a[i][j] = 0;}}}return res;
}

二最长递增子序列

问题：给定一个数组，求最长递增子序列长度。比如a[10]={4,0,2,6,1,3,5,9,6,7,8},则最长递增子序列为：0,1,3,5,6,7,8。

分析：假设数组为V,记从[0,k]之间的最长递增子序列长度为result[k]，则有：

result[k]=1+max{result[i]|0<=i<=k-1&&(V[i]<=V[k])}

代码如下：

int max_inc_seq(const vector<int> & s)
{int res = 0;vector<int> result(s.size(), 0);result[0] = 1;for (int i = 1; i < s.size(); i++){result[i] = 1;for (int j = 0; j < i; j++){if ((s[j]<=s[i]) && result[i]<(result[j] + 1)){result[i] = result[j] + 1;res = max(res, result[i]);}}}return res;
}

三 0-1背包问题

问题描述：有N件物品和一个承重为C的背包，每件物品的重量是Wi,价值为Pi,在不超过背包容量的前提下，求那几件物品可以使

背包中价值最大？

分析:假设p[i][w]表示前i个物品的最优背包解，背包容量是w。分析状态转换关系：

代码如下:

int pack(const vector<int> &w, const vector<int> &p, int W, vector<int> &every_element)
{vector<vector<int>> a(w.size() + 1, vector<int>(W + 1, 0));for (int i = 1; i <= w.size(); i++){for (int j = 1; j <= W; j++){if (w[i - 1]<= j){a[i][j] =(((a[i - 1][j])>(p[i - 1] + a[i - 1][j - w[i - 1]])) ? (a[i - 1][j]) : (p[i - 1] + a[i - 1][j - w[i - 1]]));}else{a[i][j] = a[i - 1][j];}}}for (int i =w.size(), j =p.size(); i >= 1 && j >= 1;){if (a[i][j] ==a[i - 1][j]){i--;}if (j >= w[i - 1] && a[i][j]==(p[i - 1] + a[i - 1][j - w[i - 1]])){every_element.push_back(p[i - 1]);j -= w[i - 1];i--;}}return a[w.size()][W];
}

个人感觉动态规划问题的关键在于找到一个状态转换方程，或者说是一个递推关系。没有一个固定的模式，必须自己分析出来。

同时利用数组存储中间的运算变量，可以提高效率。

四最长回文子串

问题描述：给定一个字符串，求字符串的最长回文子串。

思路：之前遇到这个问题时，思路是，对该字符串和字符串本身逆序求其最长连续公共子序列，即转化为最长公共子序列问题。后来发现其实是错误的，比如对于子序列：1234354321，其最长回文子序列为343，长度为3,。若是按照这种思路，序列1234354321和1234534321的最长连续公共子序列为1234或者4321,其长度为4。说明这种想法是错误的。后来在leetcode上发现了一种新的思路，也是动态规划。思路为：设状态为f(i,j),表示区间[i,j]是否为回文串，则状态转移方程为：

代码如下：

int getLongestPalindrome(string A, int n) {// write code herevector<vector<bool>> v(n,vector<bool>(n,false));int res=1;for(int i=0;i<n;++i){v[i][i]=true;for(int j=0;j<i;++j){v[j][i]=(A[i]==A[j]&&(i-j<2||v[j+1][i-1]));if(v[j][i]){if(res<i-j+1)res=i-j+1;}}}return res;}