动态规划初学

基本思想

  动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划法的基本思路。具体的动态规划算法多种多样，但它们具有相同的填表格式。

  也就是说如果很难将问题分解为独立的部分，或者分解的独立部分过于细碎，而且子问题的解需要重复使用时，则可以考虑使用动态规划的方法。

基本概念

  动态规划中一般将问题分为多个阶段，通常由上一阶段的决策影响下一阶段，从而确定一个完整的解决路径。

• 解决步骤：
  (1)确定问题的决策对象。
  (2)对决策过程划分阶段。
  (3)对各阶段确定状态变量。
  (4)根据状态变量确定费用函数和目标函数。
  (5)建立各阶段状态变量的转移过程，确定状态转移方程。
• 特点：
  (1)将问题分解为若干阶段，自底向上求解。
  (2)通过状态转移方程¹求最优解，归根到底最优解取决于子问题最优解。
  (3)每个子问题只求解一次，求解结果可反复利用，避免了重复操作。

小例子

最长回文子串：给定一个字符串，找到串中最长的回文子串。
如果从正面处理，从头开始遍历寻找回文串，然后选择长的丢弃短的，会对同一字符处理多次，所以可以使用动态规划的方式。

简要步骤

• 定义动态规划矩阵 dp[i][j] 表示字符串从 i 到 j 的子串
• 矩阵初值置为0，若 i 到 j 的子串为回文子串时，将dp [i][j] 置为1
• 首先判空及判断字符串长度为1的情况
• 考虑最长回文子串长度为2的情况
• 考虑最长回文子串长度大于等于3的情况

/*
* 输入：字符串s
* 输出：最长回文子串
*/
public String longestPalindrome(String s) {
	char[] ch = s.toCharArray();
	int index = 0;           //最长回文字串开始位置
	int lengthMax = 1;          //最长回文串长度
		
	int len = s.length();
	char[][] dp = new char[len][len];     //动态规划矩阵
		
	//判空
	if(s == null || s.equals("")) {
		return "";
	}
		
	//s长度为1
	if(len == 1) {
		return s;
	}
		
	//回文串长度为2
	for(int i = 0; i < len - 1; i++) {
		dp[i][i] = 1;
		int j = i + 1;
		if(ch[i] == ch[j]) {
			dp[i][j] = 1;
			index = i;
			lengthMax = 2;
		}
	}
		
	//回文串大于等于3
	for(int k = 3; k <= len; k++) {
		for(int i = 0; i < len - k + 1 ; i++) {
			int j = i + k - 1;
			//位置i与j的字符相同，且i+1到j-1的子串已经是回文子串
			if(ch[i] == ch[j] && dp[i + 1][j - 1] == 1) {
				dp[i][j] = 1;
				index = i;
				lengthMax = k;
			}
		}
	}
	    return s.substring(index, index + lengthMax);
}

  本题使用这种解法的时间复杂度为O(n²)。

总结

  动态规划可以有效地避免重复计算，比如上面的小例子，较长串的判定是依靠较短串来实现的，而较短串又是依靠更短的串来判定。这样一来只要将做过的判定全部储存，就可以在之后的判断中直接使用。

---

1. 状态转移方程的一般形式：
   一般形式： U：状态； X：策略
   顺推：f[U_k] = opt{ f[U_k-1]+L[U_k-1,X_k-1] } ，其中L[U_k-1,X_k-1]： 状态 U_k-1 通过策略 X_k-1 到达状态 U_k 的费用
   　　初始 f[U1] ，结果 f[Un] 。
   倒推：f[U_k] = opt{ f[U_k+1]+L[U_k,X_k] }，其中L[U_k,X_k]： 状态 U_k 通过策略 X_k 到达状态 U_k+1 的费用
   　　初始 f[U_n] ，结果 f[U₁] 。 ↩︎