Leetcode刷题Task02：动态规划算法（C++）

一、概念

百度百科中DP算法的概念为：

动态规划（Dynamic Programming，DP）是运筹学的一个分支，是求解决策过程最优化的过程。20世纪50年代初，美国数学家贝尔曼（R.Bellman）等人在研究多阶段决策过程的优化问题时，提出了著名的最优化原理，从而创立了动态规划。动态规划的应用极其广泛，包括工程技术、经济、工业生产、军事以及自动化控制等领域，并在背包问题、生产经营问题、资金管理问题、资源分配问题、最短路径问题和复杂系统可靠性问题等中取得了显著的效果

二、思想或策略

DP通常用来求解最优化问题，对于原问题，和分治算法一样，同样是把原问题分解为子问题，子问题与原问题有相同的形式或类似，而且子问题通常有最优解。我们把子问题对应各参数组合构成一个状态，那么每个子问题的解对应一个状态，通过转移状态的方式，我们只需要依次求出子问题状态最优解，并保存，通过转移状态从而得到原问题的解！

【注】这里和分治法的思想做下对比，DP和分治的相同之处是都将原问题分解为若干子问题，先求解子问题的解然后逐步得到原问题的解；不同的是分治法所分解的子问题相互独立，原问题的解是由子问题合并得到的，而动态规划分解的子问题往往相互关联，原问题的解由子问题解的转移得到。

三、步骤

DP编程实现的步骤：
1、确定原问题与子问题
  一般来说原问题是整个状态的最优解，那子问题就是原问题的一个最优子结构。
2、确定状态：
  就是确定某一个最优子结构对应的参数（这个参数根据题目有多有少），通常用一维数组或二维数组表示某一状态，也不乏有更难的状态，如多维数组等。
3、确定边界状态值
4、确定状态转移方程
  通常写法为：dp[i]=trans_proc(dp[0],dp[1],…,dp[i-1])，如斐波那契数列的转移方程为dp[i]=dp[i-1]+dp[i-2] (i>3)
5、确定输出
  有时需要的不一定是最后一个状态，根据情况判断。

【注】DP的关键步骤是确定状态转移方程，未优化的状态转移方程可以在代码中直接表示；根据状态转移过程状态的使用情况，可以优化方程，降低空间复杂度，但是会降低可读性。

四、DP适用的情况

原问题通常具有以下三个特征：
（1）最优化原理：题目要求某一个问题的最优解，并且该问题分解产生的子问题同样具有最优解，即含有最优子结构；
（2）状态相关性：某一状态只与该状态取值有关，而不会受后续状态改变的影响；
（3）重叠子问题：子问题不独立，在状态转移过程中之前子问题的解会在后续状态求解过程中用到。

五、C++实现DP的一般模板

//以二维DP数组为例
#define 返回类型 T
T dynamic_program(problem){
	vector<vector<T>> dp(m,vector<T>(n));  //定义dp数组
	
	dp[0][0]=xxx; //确定 单个 边界值
	for(int i=0;i<dp.size();i++){  //用for循环确定多个边界值
		dp[i][0]=...; //第一列
	}
	for(int j=0;j<dp[0].size();j++){
		dp[0][j]=...; //第一行
	}
	.....

	dp[i][j]=Trans_proc(dp[0][0],dp[0][1],...,dp[i-1][j],dp[i][j-1])  //状态转移方程编程实现

	return dp[0][0]  ||  dp[dp.size()][dp[0].size()];  //从前到后 通常返回最后一个状态;从后到前返回第一个状态
}

六、C++实现LeetCode动态规划相关例题

6.1 Leetcode5–最长回文子串

• 题目描述
  给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。

示例 2：

输入: “cbbd”
输出: “bb”

• 解题思路
  1、确定原问题与子问题
     原问题是求解字符串s的最长回文子串，那么子问题是求解字符串从i到j（i,j）的最长回文子串。
  2、确定状态
     由于结果需要返回子串，而不是长度，所以需要用两个指针记录子串起始点位置和终止点位置，用i和j表示，因为i、j都需要遍历字符串s，所以需要使用二维数组表示，定义状态dp[i][j] 表示子串s从i到j是否为回文子串。
  3、确定边界条件
     二维数组的初始值都置为False，由于数组对角线表示单个字符，一定是回文子串，需要初始化为True
  4、确定状态转移方程
  记录j-i的状态，有三种情况：
    （1）j-i == 0：表示i、j指向同一位置，子串长度为1，一定是回文
    （2）j-i ==1：表示i、j相邻，子串长度为2，只需判断s[i]是否等于s[j]即可
    （3）j-i>1：表示长字符串，那么s[i][j]=s[i]==s[j]&&dp[i+1][j-1]，即需要首尾字符相等而且(i+1,j-1)同时为回文时才会得到(i,j)是回文子串；

• C++代码实现
  根据遍历子串的方式不同，可以有两种写法，本质是一样的。
  方法一：从前到后双指针顺序遍历

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.length()<2)
            return s;
            
        int len=s.length();
        string ans;
        vector<vector<int>> dp(len,vector<int>(len)); //定义dp 数组
        
        for(int i=0;i<len;i++){ //确定边界：对角线置为1
            dp[i][i]=1;  
        }
        for(int j=1;j<len;j++){
            for(int i=0;i<=j;i++){  //i、j遍历s字符串
                if(j-i == 0){
                    dp[i][j]=1;
                }else if(j-i == 1){
                    dp[i][j]=s[i]==s[j];
                }
                else{
                    dp[i][j]=(s[i]==s[j])&&(dp[i+1][j-1]);  //状态转移方程
                }

                if(dp[i][j] && (j-i+1)>ans.size()){  //记录最长子串
                    ans=s.substr(i,j-i+1);
                }
            }    
        }
        return ans;
    }
};

写法二：根据子串长度遍历，如遍历完所有子串长度为2的子串，再遍历所有子串长度为3的子串，以此类推。

class Solution {
public:
    string longestPalindrome(string s) {
        int len=s.length();
        vector<vector<int>> dp(len,vector<int>(len)); //定义一个dp数组
        string ans;

        for(int k=0;k<len;k++){ 
            for(int i=0;i+k<len;i++){
                int j=i+k;  //每次循环k个长度的距离，得到一个子问题的解
                if(k ==0){
                    dp[i][j]=1;
                }                  
                else if(k==1){
                    dp[i][j]=s[i]==s[j];
                }   
                else{
                    dp[i][j]=(dp[i+1][j-1]&&(s[i]==s[j]));
                }

                if(dp[i][j] && (j-i+1)>ans.size()){
                    ans=s.substr(i,j-i+1);
                }
            }
        }
        return ans;
    }
};

6.2 Leetcode72–编辑距离

待续

七、总结

   DP通常用来求解最优化问题，或者有最优子结构的问题，她的关键是确定状态转移方程，从而根据需要创建dp数组，一般返回值是最后一个状态，即“最大”问题的最优解，明白了思路和步骤，DP的代码写起来通常是很简洁的。