算法（Java）——动态规划

算法相关数据结构总结：

序号	数据结构	文章
1	动态规划	动态规划之背包问题——01背包动态规划之背包问题——完全背包动态规划之打家劫舍系列问题动态规划之股票买卖系列问题动态规划之子序列问题算法（Java）——动态规划
2	数组	算法分析之数组问题
3	链表	算法分析之链表问题算法（Java）——链表
4	二叉树	算法分析之二叉树算法分析之二叉树遍历算法分析之二叉树常见问题算法（Java）——二叉树
5	哈希表	算法分析之哈希表算法（Java）——HashMap、HashSet、ArrayList
6	字符串	算法分析之字符串算法（Java）——字符串String
7	栈和队列	算法分析之栈和队列算法（Java）——栈、队列、堆
8	贪心算法	算法分析之贪心算法
9	回溯	Java实现回溯算法入门（排列+组合+子集） Java实现回溯算法进阶（搜索）
10	二分查找	算法（Java）——二分法查找
11	双指针、滑动窗口	算法（Java）——双指针算法分析之滑动窗口类问题

动态规划是经典算法的一种。在算法中动态规划算法的重要性不容置疑，本博客主要是记载自己在刷题和学习过程中对动态规划的一个理解和总结。

动态规划

定义

动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决。

动态规划算法的基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解。

与分治法最大的差别是：适合于用动态规划法求解的问题，经分解后得到的子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）。

定义比较枯燥，但却是根源。

简单来说：

拆分。把问题拆分成一步一步的可以通过递归实现的。动态规划有一类问题就是从后往前推到,有时候我们很容易知道:如果只有一种情况时,最佳的选择应该怎么做.然后根据这个最佳选择往前一步推导,得到前一步的最佳选择。
状态定义和状态与状态之间的关系。就是我们设置的动态规划列表，去表示最佳的情况。还有就是状态转移方程，该最佳状态和前状态之间的关系。
最优解。我们在保存前一状态时，可以将局部最优解存下来，后面逐步更新，可以降低时间和空间复杂度。

作用

动态规划一般用来解决：
1.计数

有多少种方式走到右下角；
有多少种方法选出k个数使得和为sum;

2.求最大值，最小值

从左上角走到右下角路径和的最大值；
最长公共子序列；
最大连续子数组和；

3.存在性

取石子游戏，先手是不是必胜；
能不能取出k个数，和为sum；

怎么用

1.确定状态（两个核心，最后一步，化成子问题）

根据最后一步，往前推。然后将问题转化成从开始到最后一步的子问题。

2.转移方程

结果=开始到最后一步+最后一步。

3.开始和边界条件

确定0，以及边界不适合转移方程的条件。

4.计算顺序

一般都是推导到从最开始计算。

整个动态规划，最难的就是定义状态。一旦状态定义出来，表明你已经抽象出子问题，可以分解原来的大问题了。

力扣关于动态规划的题

1）剑指offer47：礼物的最大价值

题目：在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

解题思路：根据题目说明，易得某单元格只可能从上边单元格或左边单元格到达。

设f(i,j)为从棋盘左上角走至单元格(i,j)的礼物最大累计价值，易得到以下递推关系：f(i,j)等于f(i,j−1)和f(i−1,j)中的较大值加上当前单元格礼物价值grid(i,j)。

因此，可用动态规划解决此问题，以上公式便为转移方程。

为了提高效率，在循环外先考虑只有一行和一列的情况。

用四步法分析：

1.确定状态
1.1最后一步

无论在棋盘上怎样走到达右下角，总有挪动最后一步向右或向下。
右下角设为（m-1,n-1）
那么前一步一定是在（m-2,n-1）或（m-1,n-2）

1.2化成子问题

走到（m-2,n-1）或（m-1,n-2）的最大值
原题要求走到（m-1,n-1）的最大值
转化为子问题
状态f(i,j)为从棋盘左上角走至单元格(i,j)的礼物最大累计价值

2.转移方程

f(i,j)等于f(i,j−1)和f(i−1,j)中的较大值加上当前单元格礼物价值grid(i,j)。

3.开始和边界条件

开始：起始位置
边界条件：第一行元素和第一列元素。

4.计算顺序
从左上角开始计算。

算法代码：

class Solution {public int maxValue(int[][] grid) {int m=grid.length,n=grid[0].length;for(int j=1;j<n;j++) grid[0][j]+=grid[0][j-1]; //第一行,只能从左边过来for(int i=1;i<m;i++) grid[i][0]+=grid[i-1][0]; //第一列,只能从右边过来for(int i=1;i<m;i++){ //从上或者左边过来，左边或上边的最大值加上格子值for(int j=1;j<n;j++){grid[i][j]+=Math.max(grid[i-1][j],grid[i][j-1]);}}  return grid[m-1][n-1];}
}

2）剑指offer42：连续子数组的最大和

题目：输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。

示例：

输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

解题思路：
动态规划解析：

状态定义：设动态规划列表dp，dp[i]代表以元素nums[i]为结尾的连续子数组最大和。

为何定义最大和dp[i]中必须包含元素nums[i]：保证dp[i]递推到dp[i+1]的正确性；如果不包含nums[i]，递推时则不满足题目的连续子数组要求。

转移方程：
若dp[i−1]≤0，说明dp[i−1]对dp[i]产生负贡献，即dp[i−1]+nums[i]还不如nums[i]本身大。

初始状态：dp[0]=nums[0]，即以nums[0]结尾的连续子数组最大和为nums[0]。

返回值：返回dp列表中的最大值，代表全局最大值。

算法代码：

class Solution {public int maxSubArray(int[] nums) {int res=nums[0];//res存储和的最大值for(int i=1;i<nums.length;i++){nums[i]+=Math.max(nums[i-1],0);//判断加入的元素是否有贡献res=Math.max(res,nums[i]);}return res;}
}

3）剑指offer63：股票的最大利润

题目：假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

示例1：
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

示例2：
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

解题思路：考虑动态规划，

状态定义：设动态规划列表dp，dp[i]代表以prices[i]为结尾的子数组的最大利润（以下简称为前i日的最大利润）。

转移方程：由于题目限定“买卖该股票一次”，因此前i日最大利润dp[i]等于前i−1日最大利润dp[i−1]和第i日卖出的最大利润中的最大值。

初始状态：dp[0]=0,即首日利润为0。

返回值：dp[n-1],其中n为dp列表长度。

时间复杂度降低：在遍历prices时，可以借助一个变量（记作cost）每日更新最低价格，优化后转移方程为：
dp[i]=max(dp[i-1],prices[i]-min(cost,prices[i]))

空间复杂度降低：由于dp[i]只与dp[i-1],prices[i],cost相关，可用一个变量（记作利润profit）代替dp列表，优化后转移方程：
profit=max(profit,prices[i]-min(cost,prices[i]))

算法代码：

class Solution {public int maxProfit(int[] prices) {int cost = Integer.MAX_VALUE, profit=0;for(int price : prices){cost=Math.min(cost,price); //记录更新最小值profit=Math.max(profit,price-cost); //转移方程比较最大利润}return profit;}
}