[一篇看懂] 最优化问题: 分治法 贪心算法 动态规划(举例说明)
欢迎指教 欢迎评论留言
分治算法
- 先划分, 大问题变小问题,
- 等到问题规模小到可以直接解决了,再去处理这个足够小的子问题
- 最后将子问题的最优解’合并’起来, 组合成原问题的最终解.
三种解决方案都是将大规模的难解的问题改成小规模容易解的问题.
比如分治算法经典的’最大子序和’问题.
举例:53. 最大子序和
给定一个整数数组
nums，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例:
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
分治算法解分析
class Solution {
public int maxSubArray(int[] nums) {
// 最优子串可能在左串 可能在右串 可能是包含中间元素的中间串
return recur(nums,0,nums.length-1);
}
// 递归 分治法
private int recur(int[] nums, int l, int r) {
if(l==r) return nums[l];// 只有一个元素的时候
int mid=(l+r)/2;
// 对左中右取最大
int leftSum=recur(nums,l,mid);
int rightSum=recur(nums,mid+1,r);
// cross的计算不是原问题规模更小的问题 是合并的一部分
int crossSum=midSum(nums, l, r, mid);
int res=Math.max(leftSum, Math.max(rightSum, crossSum));
return res;
}
// 求中间子串: 这个求和不是原问题的子问题(必须 跨越中点) 所以不用recur()计算
private int midSum(int[] nums, int l, int r,int mid) {
if(l==r) return nums[l];// 只有一个元素
int sumTmp=0,leftSum=Integer.MIN_VALUE;
int rightSum=leftSum;
for(int i=mid;i!=-1;i--) {
sumTmp+=nums[i];
leftSum=Math.max(sumTmp, leftSum);
}// 包括mid位置的左半边最大和
sumTmp=0;
for(int i=mid+1;i!=nums.length;i++) {
sumTmp+=nums[i];
rightSum=Math.max(sumTmp, rightSum);
}// 不包括mid位置的右半边最大和
return leftSum+rightSum;
}
}
分析原问题,发现问题的解无外乎三中情况. 子序列都在在mid的前面, 或子序列都在mid的后面, 或子序列不都在前面也不都在后面, 跨越了mid, 前后都有的, 代码中的midSum函数就是算这个的.
原问题划分为:
- 1.前半部分和 2. 后半部分和 3. 包括中间的中间部分和.
前后半部分都是大问题变小问题经典的形式, 中间部分和不是原问题的同结构子问题, 所以是属于分治算法的合并部分
动态规划算法
- 三种解决方案都需要’最优子结构’形式,
- 分治的最优子问题互相独立, 没有’重叠子问题’的情况; 如果有这个问题,直接使用分治算法会有许多的子问题需要重复计算. 用动态规划可以大大的减少时间花销.
- 动态规划有自顶向下和自底向上两种方法:
- 自顶向下方法其实就是带备忘录的分治算法, 在每次递归调用时, 将结果存在一个’备忘录’中, 它可以是一个数组. 在需要子问题解的时候不需要再次计算子问题的解, 直接返回先前已经计算的结果(如果没有计算过的话就继续计算)
- 自底向上的方法其实是从小规模问题到大规模问题, 计算较大规模最优解是会利用到刚刚(上回循环)计算出的较小规模最优解的结果, 每个子问题只会计算一次, 大大减少时间复杂度.自底向上说到底就是在大问题可以化成小问题的基础想, 从小问题出发, 逐渐扩大, 最终扩大到原本问题的规模
举例: 55. 跳跃游戏
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
动态规划算法分析
回溯法
public class Solution {
public boolean canJumpFromPosition(int position, int[] nums) {
if (position == nums.length - 1) return true;
int furthestJump = Math.min(position + nums[position], nums.length - 1);// 避免跳到超出数据容量处去了
for (int nextPosition = position + 1; nextPosition <= furthestJump; nextPosition++) // 从position+1处开始找能跳的点
if (canJumpFromPosition(nextPosition, nums))
return true;
return false;
}
public boolean canJump(int[] nums) {
// 从0开始遍历递归
return canJumpFromPosition(0, nums);
}
}
- 时间复杂度是O(2^n), 幂级的时间复杂度, 很明显需要优化
- 原问题有’最优子结构’, 的确是不断缩小范围. 并且在递归的过程中有很多重复的子问题的计算
- 对于重复子问题往往使用动态规划可以优化时间复杂度
- 并且发现这种分治每次缩小范围都是只剩下一个子问题, 说不定可以使用贪心算法(下文会说)
自顶向下(用空间换时间)
enum Index { // 设计了一个每局变量
GOOD, BAD, UNKNOWN
}
public class Solution {
Index[] memo;// 判断每一个位置能不能跳到尾巴(end)
public boolean canJump(int[] nums) {
memo = new Index[nums.length];
for (int i = 0; i < memo.length; i++)
memo[i] = Index.UNKNOWN;// 初始化memo数组
memo[memo.length - 1] = Index.GOOD;// 最尾巴位置可以跳
return canJumpFromPosition(0, nums);
}
private boolean canJumpFromPosition(int position, int[] nums) {
// 以下两行就是动态规划自顶向下的精髓(也叫带备忘录的动态规划)
if (memo[position] != Index.UNKNOWN) // 若当前位置可以跳 直接返回
return memo[position] == Index.GOOD ? true : false;
//若对应的子问题没有求解过, 则继续计算
int furthestJump = Math.min(position + nums[position], nums.length - 1);// 避免跳到超出数据容量处去了
for (int nextPosition = position + 1; nextPosition <= furthestJump; nextPosition++) {// 从position+1处开始找能跳的点
if (canJumpFromPosition(nextPosition, nums)) {
memo[position] = Index.GOOD;
return true;
}
}
// 找不到能跳的点
memo[position] = Index.BAD;
return false;
}
自底向上
public boolean canJump2(int[] nums) {
// can数组标识当前位置是否能跳到尾巴(end)
boolean[] can=new boolean[nums.length];// 默认为false
can[nums.length-1]=true;// 最尾为真(可跳)
int jumpMax=0;//最远可跳的距离
for(int i=nums.length-2;i>=0;i--) {//从len-2向前遍历
//i+nums[i]是i处可跳的距离
jumpMax=Math.min(i+nums[i], nums.length-1);
for(int j=i+1;j<=jumpMax;j++)//从i+1遍历到jumpMax 看有没有可达尾的
if(can[j])
can[i]=true; break;
}
return can[0];
}
贪心算法
贪心算法通常是自顶向下的算法, 每一步贪心都把当前问题的规模缩减一点
贪心算法在使用时要证明(相当于做了数学归纳法):
- 证明做出当前的贪心选择后**, 只剩下一个子问题**, 不能像分治和动态一样有多个子问题.
- 证明贪心选择总是安全的, 能够一路贪心贪到原问题最优解
- 贪心算法实际是对每一步的当前问题找最优解, 不依赖于子问题的最优解和将来选择的最优解
优化
如果在贪心算法的每步操作时, 不得不考虑众多选择: 很多时候需要对原问题的输入输入做点排序操作. 便于每步贪心时减少’查找当前问题最优解’的时间复杂度.
举例: 跳跃游戏
public boolean canJump(int[] nums) {
int leftMostIndex=nums.length-1;// 初始化为最右元素
for(int i=nums.length-1;i>=0;i--) {// 从后往前
//每次遍历贪到最右(最大下标)
if(nums[i]+i>=leftMostIndex)//i处的元素够得到 '最左可达元素'
leftMostIndex=i;
}
return leftMostIndex==0;
}
- 每步贪心的确是可以缩减规模, 并只剩下左部分规模的子问题
- 每步都贪’最左’的元素, 如果最左元素都够不到的话, 就是不可达, 如果最左元素够得到, 那就是可达
举例2: 最大子序和
class Solution {
public int maxSubArray(int[] nums) {
int len = nums.length;
int currSum = nums[0]; // 每一步的当前最优解
int maxSum = nums[0];
// 从左到右 每步贪心
for (int i = 1; i < len; ++i) {
// 每步都贪出当前 以j结尾的最大值;
currSum = Math.max(nums[i], currSum + nums[i]);
// 更新maxSum
maxSum = Math.max(maxSum, currSum);
}
return maxSum;
}
}
currSum = Math.max(nums[j], currSum + nums[j]);- 比较以j结尾的某个’最大子数组和’和[j]的值
- 若[i,j]的值更大或二者相等
- '最大子数组’加一个元素
- currSum更新为[i,j]的大小
- 若[i,j]的值比[j]的值小
- 还不如从j开始新的’最大连续子数组’
- 更新’currSum’
- 若最大子数组不是以[j-1]结尾的
- 其对应的值早就存在maxSum中,是currSum的曾经的某一个赋值
maxSum = Math.max(maxSum, currSum);比较时也不会影响maxSum的正确性
贪心算法常见解决问题
单源最短路径问题, 最小生成树问题