动态规划的概念复习
每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。
动态规划的思想和策略
将待求解的问题分解为若干个子问题，按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。
适合用动态规划求解的问题，经分解后得到的子问题往往不是互相独立的。（这一点与分治法不同）
能用动态规划求解的问题一般具有三个性质
1.最优化原理（最优子结构性质）
2.无后效性（当前状态一旦确定，就不受以后状态决策的影响）
3.有重叠子问题（子问题不相互独立，因而当前子问题的解可以为以后子问题的解提供参考）
动态规划求解的基本步骤
1.划分阶段
2.确定状态和状态变量
3.确定决策并写出状态转移方程
4.寻找边界条件
例题深入
1.字符串解码
问题描述：一个包含字母的消息被加密后变成了只包含数字的字符串，我们现在知道加密的规则：A–>1 ; B–>2 …… Z–>26 ;
现在给定一个已经被加密的只包含数字的字符串，求出该字符串有多少种被解密的方法。例如 “12” -> AB 或者 “12”->L 。
分析：假设定义一个数组，dp[i]为到第i个数字所能够组成的所有解码方式的个数，那么对于dp[i+1]来说，如果第i个数字和第i+1个数字不能构成一个字符的编码，那么第i+1个数字单独解码，解码方式的个数和有i个数字是相同的，即 dp[i+1] = dp[i] ；反之，如果第i个数字和第i+1个数字能构成一个字符的编码，那么解码方式的个数就等于前i-1个数字的解码方式个数加上前i个数字的解码方式的个数，即dp[i+1] = dp[i] + dp[i-1],因为此时你可以选择第i+1个数字单独解码，那么方法数等于dp[i],或者第i个和第i+1个一起编码，方法数等于dp[i-1]。
代码实现
#include<iostream>
#include<string>
#include<vector>
using namespace std;
/**
* 求解字符串的解码方法总数
* @param str 需要解码的字符串
* @return int 解码方法的总数
*/
int Decod_num(string& str){
//定义一个数组记录解码方式的个数
vector<int> vec( str.size() , 1 );
//只有一个数字，解码方式就一种
if( str.size() < 2 ){
return 1 ;
}
//26以内的数字，解码方式两种
if( str[0] == '1' || (str[0] == '2' && str[1] <= '6')){
vec[1] = 2 ;
}
int i ;
int tmp ;
//动态规划求解过程
for( i = 2 ; i < str.size() ; i ++ ){
//判断是合法的字符
if( str[i] >= '0' && str[i] <= '9'){
//状态转移1，i个数字的解码方法数至少是前i-1个数字的解码方法数
vec[i] = vec[i-1];
}else{
return 0 ;
}
tmp = str[i-1] - '0';
tmp = tmp*10 + str[i]-'0';
//判断最后两个数字是否能构成一个字符的编码
if( str[i-1] != '0' && tmp <= 26){
//状态转移2, i个数字的解码方法数等于前i-1个数字的解码方法数加上前i-2个数字的解码方法数
vec[i] += vec[i-2];
}
}
//数组的最后一位即当前字符串的解码方法总数
return vec[str.size()-1];
}
2.矩阵最小路径和
问题：给定一个二维矩阵，矩阵的每个元素指定了走到该出所需要的代价，要你从矩阵左上角到右下角，寻找代价最小的一条路径。
分析：到达矩阵的一个点，有两种走法，一是从上面一个格子走过来，一是从左边的格子走过来（边界点除外）。那么，到达一点的最短路径，要么就是到达该点左边一个点的最小代价加上该点的代价，要么就是到达该点上面一个点的最小代价加上该点的代价，两者中的最小值。
即状态转移方程
dp[i][j] = min( dp[i-1][j] + vec[i][j] , dp[i][j-1] + vec[i][j] )
代码实现
/**
* 求解矩阵从左上角到右下角的最小路径代价
* @param vec 矩阵的二维数组
* @return int 最小的路径代价
*/
int MinPathSum( vector<vector<int>> & vec ){
vector<vector<int>> dp( vec.size() );
int i,j ;
//初始化动态规划需要的数组
for( i = 0 ; i < vec.size() ; i ++ ){
dp[i].assign(vec[i].size(),numeric_limits<int>::max());
}
dp[0][0] = vec[0][0];
//初始化边界值
for( i = 1 ; i < vec.size() ; i++ ){
dp[i][0] = vec[i][0]+dp[i-1][0];
}
for( j = 1 ; j < vec[0].size() ; j++ ){
dp[0][j] = vec[0][j]+dp[0][j-1];
}
//求解过程
int temp ;
for( i = 1 ; i < vec.size() ; i ++ ){
for( j = 1 ; j < vec[0].size() ; j ++ ){
tmp = min(vec[i][j] + dp[i][j-1] , vec[i][j] + dp[i-1][j]);
if( tmp < dp[i][j] ){
dp[i][j] = temp ;
}
}
}
return dp[vec.size()-1][vec[0].size()-1];
}3.最大子数组乘积
问题：给定一个整数数组，求解乘积最大的子数组的值
分析：由于数组中可能出现负数，所以当前最大值，可能是之前最大乘以当前值（如果之前最大乘积为正数，且当前数也为正数），也可能是之前最小乘以当前值（如果之前最小乘积为负数，且当前值也为负数，负负得正），也可能是当前数。
所以为了得到全局最优，我们需要两个数组来存储局部最优值，一个保存局部最大值（正数），一个保存局部最小值（负数）,并不断更新两个局部最优。
代码实现
/**
* 求解最大子数组乘积
* @param vec 一维数组
* @return int 最大乘积
*/
int maxProduct( vector<int>& vec){
if( vec.size() == 0 ){
return 0 ;
}
//一维规划，但是需要两个数组来保存两个局部最优值，以得到全局最大
vector<int> maxcur(vec.size(),0);
vector<int> mincur(vec.size(),0);
maxcur[0] = vec[0];
mincur[0] = vec[0];
int maxproduct = vec[0];
int i , temp ;
for( i = 1 ; i < vec.size() ; i ++ ){
//更新局部最大值
maxcur[i] = max( vec[i] , max(maxcur[i-1]*vec[i],mincur[i-1]*vec[i]));
//更新局部最小值
mincur[i] = min( vec[i] , min(mincur[i-1]*vec[i],maxcur[i-1]*vec[i]));
//更新全局最大值
maxproduct = max( maxcur[i] , maxproduct );
}
return maxproduct ;
}