题目一：最大正方形
在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。
示例:
输入:
1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0
输出: 4
方法一：暴力法
由于正方形的面积等于边长的平方，因此要找到最大正方形的面积，首先需要找到最大正方形的边长，然后计算最大边长的平方即可。
暴力法是最简单直观的做法，具体做法如下：
遍历矩阵中的每个元素，每次遇到 1，则将该元素作为正方形的左上角；确定正方形的左上角后，根据左上角所在的行和列计算可能的最大正方形的边长（正方形的范围不能超出矩阵的行数和列数），在该边长范围内寻找只包含 1 的最大正方形；
每次在下方新增一行以及在右方新增一列，判断新增的行和列是否满足所有元素都是 1。
java
public int maximalSquare(char[][] matrix) {
int maxSide = 0;
if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
return maxSide;
}
int rows = matrix.length, cols = matrix[0].length;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (matrix[i][j] == '1') {
// 遇到一个1作为作为矩形的左上角
maxSide = Math.max(maxSide, 1);
// 计算可能的最大正方形的边长
int currentSide = Math.min(rows - i, cols - j);
for (int k = 1; k < currentSide; k++) {
// 判断新增的一行一列是否均为1
boolean flag = true;
if (matrix[i + k][j + k] == '0') {
break;
}
for (int m = 0; m < k; m++) {
if (matrix[i + k][j + m] == '0' || matrix[i + m][j + k] == '0') {
flag = false;
break;
}
}
if (flag) {
maxSide = Math.max(maxSide, k + 1);
} else {
break;
}
}
}
}
}
return maxSide * maxSide;
}
python
def maximalSquare(self, matrix: list[list[str]]) -> int:
if len(matrix) == 0 or len(matrix[0]) == 0:
return 0
maxSide = 0
rows, columns = len(matrix), len(matrix[0])
for i in range(rows):
for j in range(columns):
if matrix[i][j] == '1':
# 遇到一个 1 作为正方形的左上角
maxSide = max(maxSide, 1)
# 计算可能的最大正方形边长
currentMaxSide = min(rows - i, columns - j)
for k in range(1, currentMaxSide):
# 判断新增的一行一列是否均为 1
flag = True
if matrix[i + k][j + k] == '0':
break
for m in range(k):
if matrix[i + k][j + m] == '0' or matrix[i + m][j + k] == '0':
flag = False
break
if flag:
maxSide = max(maxSide, k + 1)
else:
break
maxSquare = maxSide * maxSide
return maxSquare
方法二：动态规划
用 dp(i,j) 表示以 (i, j) 为右下角， 且只包含 1 的正方形的边长最大值。如果我们能计算出所有dp(i, j) 的值， 那么其中的最大值即为矩阵中只包含 1 的正方形的边长最大值，其平方即为最大正方形的面积。那么如何计算 dp 中的每个元素值呢？对于每个位置 (i, j)，检查在矩阵中该位置的值：
如果该位置的值是 0，则 dp(i, j) = 0，因为当前位置不可能在由 1组成的正方形中；
如果该位置的值是 1，则 dp(i, j) 的值由其上方、左方和左上方的三个相邻位置的 dp 值决定。
具体而言，当前位置的元素值等于三个相邻位置的元素中的最小值加 1，状态转移方程如下：
dp(i,j)=min(dp(i-1,j),dp(i-1,j-1),dp(i,j-1))+ 1
此外,还需要考虑边界条件。如果i和j中少有-一个为0,则以位置(i,j)为右下的最大方形的边长只能是1,因此dp(i,i)= 1。
java
public int maximalSquare1(char[][] matrix) {
int maxSide = 0;
if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
return maxSide;
}
int rows = matrix.length, cols = matrix[0].length;
int[][] dp = new int[rows][cols];
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (matrix[i][j] == '1') {
if (i == 0 || j == 0) {
dp[i][j] = 1;
} else {
dp[i][j] = Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
}
maxSide = Math.max(maxSide, dp[i][j]);
}
}
}
return maxSide * maxSide;
}
python
def maximalSquare(self, matrix: list[list[str]]) -> int:
if len(matrix) == 0 or len(matrix[0]) == 0:
return 0
maxSide = 0
rows, columns = len(matrix), len(matrix[0])
dp = [[0] * columns for _ in range(rows)]
for i in range(rows):
for j in range(columns):
if matrix[i][j] == '1':
if i == 0 or j == 0:
dp[i][j] = 1
else:
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1
maxSide = max(maxSide, dp[i][j])
maxSquare = maxSide * maxSide
return maxSquare
题目二：最低票价
在一个火车旅行很受欢迎的国度，你提前一年计划了一些火车旅行。在接下来的一年里，你要旅行的日子将以一个名为 days 的数组给出。每一项是一个从 1 到 365 的整数。
火车票有三种不同的销售方式：
一张为期一天的通行证售价为 costs[0] 美元；
一张为期七天的通行证售价为 costs[1] 美元；
一张为期三十天的通行证售价为 costs[2] 美元。
通行证允许数天无限制的旅行。 例如，如果我们在第 2 天获得一张为期 7 天的通行证，那么我们可以连着旅行 7 天：第 2 天、第 3 天、第 4 天、第 5 天、第 6 天、第 7 天和第 8 天。
返回你想要完成在给定的列表 days 中列出的每一天的旅行所需要的最低消费。
示例 1：
输入：
days = [1,4,6,7,8,20], costs = [2,7,15]
输出：11
解释：
例如，这里有一种购买通行证的方法，可以让你完成你的旅行计划：
在第 1 天，你花了 costs[0] = $2 买了一张为期 1 天的通行证，它将在第 1 天生效。
在第 3 天，你花了 costs[1] = $7 买了一张为期 7 天的通行证，它将在第 3, 4, …, 9 天生效。
在第 20 天，你花了 costs[0] = $2 买了一张为期 1 天的通行证，它将在第 20 天生效。
你总共花了 $11，并完成了你计划的每一天旅行。
示例 2：
输入：days = [1,2,3,4,5,6,7,8,9,10,30,31], costs = [2,7,15]
输出：17
解释：
例如，这里有一种购买通行证的方法，可以让你完成你的旅行计划：
在第 1 天，你花了 costs[2] = $15 买了一张为期 30 天的通行证，它将在第 1, 2, …, 30 天生效。
在第 31 天，你花了 costs[0] = $2 买了一张为期 1 天的通行证，它将在第 31 天生效。
你总共花了 $17，并完成了你计划的每一天旅行。
提示：
1 <= days.length <= 365
1 <= days[i] <= 365
days 按顺序严格递增
costs.length == 3
1 <= costs[i] <= 1000
方法：动态规划
思路
今天不需要出门，不用买票 今天如果要出门，需要买几天？ 看往后几天（最多30天内）要不要出门 30天内都没有要出行的，那只买今天就好有要出门的（不同决策） 这次 和 后面几次 分开买更省 这次 和 后面几次 一起买更省
细化思路
上述思路显而易见，最关键在于：
「今天买多少，得看后几天怎么安排」，即 「前面依赖后面」——从后向前来买。如图所示，例 days = [1,4,6,7,8,20] 第 21 及以后的日子都不需要出门，不用买票 第 20 需要出门，需要买几天？ 不考虑 20 之前要不要出门，否则与思路相违背 第 20之后没有出门日，故买「一天」的 costs[0] 最省钱
第 9 - 19 不需要出门，则不用买，第 8 需要出门，需要买几天？ 往后（只需看往后30天）有出门的需求
决策1：买一天期，后面的不包
决策2：买七天期，包到第 8 + 7 - 1 天，第8 + 7 天往后的不包
决策3：买三十天期，包到第 8 + 30 - 1 天，第 8 + 30 天往后的不包
决策3 包三十天期的话，第 20 可不用花钱
假设题目只有 [8, 20] 两天需要出行，则int result8 = min(c[0] + c[0], c[1] + c[0], c[2] + 0); // 第 8 天 = min(决策1，决策2, 决策3);
抽象定义状态，确定从后向前的递推公式 将上述结果换个说法：「result 为第 8 天开始，所需最小费用 累计」 抽象定义状态：
「dp[i] 为第 i 天开始，所需最小费用 累计」 则 dp[i] = min(决策1, 决策2, 决策3); = min(c[0] + 1天后不包, c[1] + 7天后不包, c[2] + 30天不包); = min(c[0] + dp[i + 1], c[1] + dp[i + 7], c[2] +dp[i + 30])
java
public int mincostTickets(int[] days, int[] costs) {
int len = days.length, maxDay = days[len - 1], minDay = days[0];
int[] dp = new int[maxDay + 31];// 多扩几天，免得判断365的限制
// 只需要maxDay-minDay，此区间外都不需要出门。不会增加费用
for (int d = maxDay, i = len - 1; d >= minDay; d--) {
// i表示索引
// 也可以提前把所有的days放入Set，通过set.contains判断
if (d == days[i]) {
dp[d] = Math.min(dp[d + 1] + costs[0], dp[d + 7] + costs[1]);
dp[d] = Math.min(dp[d], dp[d + 30] + costs[2]);
i--;// 别忘了递减一天
} else {
dp[d] = dp[d + 1];// 不需要出门
}
}
return dp[minDay];// 从后向前遍历，返回最前的minDay
}
python没写，不过都大同小异了。
动态规划也不是很懂，大多数都是参照别人的思路，看来还得继续努力了呀！
2349
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
