算法-最大矩形(动态规划)

不说废话了,直接贴题

题意:

给你一个二维矩阵,权值为False和True,找到一个最大的矩形,使得里面的
值全部为True,输出它的面积

样例:

给你一个矩阵如下

[
  [1, 1, 0, 0, 1],
  [0, 1, 0, 0, 1],
  [0, 0, 1, 1, 1],
  [0, 0, 1, 1, 1],
  [0, 0, 0, 0, 1]
]
输出6

1.建立模型

这个题如果直接来解决的话,可能有很大的难度,所以,我们必须先建立模型。

首先我们来看一个题,是LeetCode上:

题意:

Given n non-negative integers representing the histogram‘s bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10 unit.

样例:

For example,
Given heights = [2,1,5,6,2,3],
return 10.

(1).暴力解法

这个题暴力解法非常的简单,就是遍历数组,向前和向后计算当前柱状图能够构成的最大矩形。至于解法这里不详述,我们的目的引出另一个方法。

(2).栈法

解题思路:首先我们将第一个柱状图在数组里面的下标(之后称为下标)压栈,之后的柱状图需要我们来判断是否需要压栈。如果新的柱状图高度大于栈顶柱状图的高度,那么就当前这个柱状图的下标压栈;如果小于的话,那么我们可以计算当前栈顶及其之前的柱状图面积,于是,我们将栈顶的下标pop出来,计算它的面积。

pop之后,我们再次判断当前的栈顶的高度是否大于新柱状图的高度,如果大于,则压栈;反之,则计算面积,这里计算面积的时候需要注意的是:计算pop出来的柱状图的面积(从pop出来的柱状图到新的柱状图,不包含新的柱状图,因为新的柱状图的高度小于当前pop出来的高度)高度等于它本身的高度,而宽度则是当前的新的柱状图的下标-pop出来的之后的栈顶的下标 - 1。

为什么是这样呢?因为pop出来的之后的栈顶柱状图与pop出来的柱状图之间可能还有其他柱状图,只是在之前的操作被pop出去了,所以,这里需要这样计算宽度。

如果理解了思路,那么代码就非常理解了

 1     public int largestRectangleArea(int[] heights) {
 2         if (heights == null || heights.length == 0) {
 3             return 0;
 4         }
 5         Stack<Integer> stack = new Stack<>();
 6         //压入第一个柱状图的下标
 7         stack.push(0);
 8         int i = 1;
 9         int max = heights[0];
10         //当i < heights.length 或者栈不为空时,这里之所以需要判断栈不为空,是因为
11         //可能有些高度很小的柱状图,一直停留在栈中,没有机会pop出来计算面积,所以最后需要一一的pop出来
12         //计算面积
13         while (i < heights.length || (i == heights.length && !stack.isEmpty())) {
14             //当当前的高度大于大于栈顶的高度或者栈为空时,将当前的下标压栈
15             if (i < heights.length && (stack.isEmpty() || heights[stack.peek()] <= heights[i])) {
16                 stack.push(i);
17                 i++;
18             } else { //计算面积
19                 int top = heights[stack.pop()]; //得到栈顶的高度
20                 //计算面积,当当前的栈为空时,直接是top * i(i里面已经包含了中间被pop出去的柱状图);不为空时,
21                 //则使用相对位置计算
22                 int currMax = !stack.isEmpty() ? (i - stack.peek() - 1) * top : top * i;
23                 //更新最大值
24                 max = Math.max(max, currMax);
25             }
26         }
27         return max;
28     }

2.利用模型解决问题

现在回到我们要解决的问题上去,我们利用类似于上面的方法来解决,将数组转换:

0 0 1 1 0 -> 0 0 1 1 0
0 0 1 1 0 -> 0 0 2 2 0
1 1 0 0 0 -> 1 1 0 0 0
1 1 1 0 0 -> 2 2 1 0 0

需要注意的是,转换的规则是:每行的遍历,如果当前位置(假设nums[i][j])为true,那么dp[i][j](转换之后的数组) = dp[i - 1][j - 1];反之,如果为false,则置为0。当i = 0时,另当别论。

数组转换成功之后,我们只需要计算每一行的最大矩形面积,其中dp数组中0,1,2之类的表示的这个矩形的高度,当每一行的最大矩形都计算出来之后,取得最大值自然是最终的答案

 1     public int maximalRectangle(boolean[][] matrix) {
 2         if (matrix == null || matrix[0].length == 0) {
 3             return 0;
 4         }
 5         //转换之后的数组
 6         int dp[][] = new int[matrix.length][matrix[0].length];
 7         for (int i = 0; i < matrix.length; i++) {
 8             for (int j = 0; j < matrix[0].length; j++) {
 9                 if (i == 0) {
10                     //i = 0的情况
11                     dp[i][j] = matrix[i][j] ? 1 : 0;
12                 } else {
13                     //不等于0
14                     dp[i][j] = matrix[i][j] ? dp[i - 1][j] + 1 : 0;
15                 }
16             }
17         }
18         int max = 0;
19         //遍历每一行
20         for (int i = 0; i < matrix.length; i++) {
21             //取得每一行的最大值
22             int temp = findRowMax(dp[i]);
23             //更新最大值
24             max = Math.max(max, temp);
25         }
26         return max;
27     }
28
29     private int findRowMax(int[] heights) {
30         if (heights.length == 0) {
31             return 0;
32         }
33         Stack<Integer> stack = new Stack<>();
34         stack.push(heights[0]);
35         int i = 1;
36         int max = heights[0];
37         while (i < heights.length || (i == heights.length && !stack.isEmpty())) {
38             if (i < heights.length && (stack.isEmpty() || heights[i] >= heights[stack.peek()])) {
39                 stack.push(i);
40                 i++;
41             } else {
42                 int height = heights[stack.pop()];
43                 int currMax = !stack.isEmpty() ? (i - stack.peek() - 1) * height : height * i;
44                 max = Math.max(currMax, max);
45             }
46         }
47         return max;
48     }
时间: 2024-10-23 04:26:04

算法-最大矩形(动态规划)的相关文章

算法导论 之 动态规划 - 矩阵链相乘

1 引言 在大学期间,我们学过高等数学中的线性规划,其中有关于矩阵相乘的章节:只有当矩阵A的列数与矩阵B的行数相等时,A×B才有意义.一个m×n的矩阵A(m,n)左乘一个n×p的矩阵B(n,p),会得到一个m×p的矩阵C(m,p).矩阵乘法满足结合律,但不满足交换律. 假设现要计算A×B×C×D的值,因矩阵乘法满足结合律,不满足交换律,即:A.B.C.D相邻成员的相乘顺序不会影响到最终的计算结果,比如: A×(B×(C×D)).A×((B×C)×D).(A×B)×(C×D).A×(B×C)×D.

《Java算法》Java动态规划

1. 算法思想: 动态规划(dynamic programming)是运筹学的一个分支,是求解决策过程(decision process)最优化的数学方法.动态规划实际上是一类题目的总称,并不是指某个固定的算法.动态规划的意义就是通过采用递推(或者分而治之)的策略,通过解决大问题的子问题从而解决整体的做法.动态规划的核心思想是巧妙的将问题拆分成多个子问题,通过计算子问题而得到整体问题的解.而子问题又可以拆分成更多的子问题,从而用类似递推迭代的方法解决要求的问题. 2. 应用场景:适用动态规划的问

算法整理之动态规划

我现在介绍的这个版本,是从算法爱好者中看到的一个别人的漫画版本.题目:有一座高度是10级台阶的楼梯,从下往上走,每跨一步只能向上1级或者2级台阶.要求用程序来求出一共有多少种走法.比如,每次走1级台阶,一共走10步,这是其中一种走法.我们可以简写成 1,1,1,1,1,1,1,1,1,1.再比如,每次走2级台阶,一共走5步,这是另一种走法.我们可以简写成 2,2,2,2,2. 分析:这种问题是典型的使用动态规划解决的问题,在使用动态规划的方法之前,能想到的方法可能就是使用排列组合,这是一个非常复

算法导论学习-动态规划之记忆化搜索

一. 动态规划 动态规划(dynamic programming),与“分治思想”有些相似,都是利用将问题分 为子问题,并通过合并子问题的解来获得整个问题的解.于“分治”的不同之处在 于,对于一个相同的子问题动态规划算法不会计算第二次,其实现原理是将每一个计算过的子问题的值保存在一个表中. 二. 记忆化搜索 我们常见的动态规划问题,比如流水线调度问题,矩阵链乘问题等等都是“一步接着一步解决的”,即规模为 i 的问题需要基于规模 i-1 的问题进行最优解选择,通常的递归模式为DP(i)=optim

常用算法整理:动态规划上

什么是动态规划 动态规划是应该不能叫 一种算法,而应该叫 一类算法 或者 说是 一种思想.它和 二分查找 这种算法是不同的,二分查找我们可以用代码表示出来,并且解决所有问题的思路几乎都是一样的.而动态规划其实无法用代码表示出来,每一种问题的解决方法可能用代码写出来都不一样,所以只看动态规划的定义是很难理解的,需要拿多个题目联系才能真正理解. 动态规划的特点就是把一个大的问题分解为若干个小问题,并且这些小问题之间,每一个小问题都可通过前面的小问题计算出来.通常这些小问题其实都是一个具体的状态.如果

算法学习之动态规划(求矩阵连乘最小相乘次数)

基本思想:动态规划算法与分治法类似,其基本思想是将带求解的问题划分成若干个独立子问题,根据求得子问题的解合并而得到原问题的解.而动态规划划分的子问题往往不是相互独立的,因此若采用同分治法相同的求解问题的方法会导致大量的子问题被重复计算,为了避免这种情况发生,我们可以用一个表来记录我们求得的子问题的解,无论该子问题的解以后是否会用到,只要被计算,就将其填入表中.这便是动态规划的基本思想. 求解的基本步骤: (1)找出最优解的性质,并刻画其结构特征. (2)递归的定义最优值. (3)以自底向上的方式

【算法参考】动态规划1

1.什么是动态规划 动态规划,和分治法一样,是通过组合子问题的解而解决整个问题的.但不同的是,分治算法是指将问题划分成一些独立的子问题,递归求解各子问题,然后合并子问题的解而得到原问题的解.而动态规划适用于子问题不是独立的情况,也就是各子问题包含公共的子子问题.动态规划对每个子子问题只求解一次,将其结果保存在一张表中,从而避免每次遇到各个子问题时重新计算答案. 2.动态规划中的几个重要性质 2.1最优子结构: 用动态规划求最优化问题的第一步是描述最优解的结构.如果问题的一个最优解中包含子问题的最

五大常用算法----贪心、动态规划、分支限界、分治算法和回溯算法

五大常用算法之一:贪心算法 所谓贪心算法是指,在对问题求解时,总是做出在当前看来是最好的选择.也就是说,不从整体最优上加以考虑,他所做出的仅是在某种意义上的局部最优解. 贪心算法没有固定的算法框架,算法设计的关键是贪心策略的选择.必须注意的是,贪心算法不是对所有问题都能得到整体最优解,选择的贪心策略必须具备无后效性,即某个状态以后的过程不会影响以前的状态,只与当前状态有关. 所以对所采用的贪心策略一定要仔细分析其是否满足无后效性. 五大常用算法之二:动态规划算法 五大常用算法之三:分支限界算法

【算法导论】动态规划之“最优二叉搜索树”

之前两篇分别讲了动态规划的"钢管切割"和"矩阵链乘法",感觉到了这一篇,也可以算是收官之作了.其实根据前两篇,到这里,也可以进行一些总结的,我们可以找到一些规律性的东西. 所谓动态规划,其实就是解决递归调用中,可能出现重复计算子问题,从而导致耗费大量时间,去做重复劳动的问题.解决思路就是,将重复做过的子问题的结果,先存起来,等之后再需要用到的时候,直接拿过来用,而不需要再去计算. 但是这里还需要注意一些地方: ①要解决的问题,比如"钢管切割"中的