动态规划巧解01矩阵最大方

要在一个由 '0' 和 '1' 组成的二维矩阵中找到只包含 '1' 的最大正方形，并返回其面积，可以使用动态规划的方法。动态规划能够有效地解决这类问题，通过构建一个辅助数组来记录以每个位置为右下角的最大正方形的边长。

算法思路

1. 动态规划数组定义：
   • 定义一个二维数组 dp，其中 dp[i][j] 表示以 matrix[i][j] 为右下角的最大正方形的边长。
   • 初始化 dp 数组，dp[0][j] 和 dp[i][0] 的值取决于 matrix[i][j] 是否为 '1'。
2. 状态转移方程：

   • 如果 matrix[i][j] 为 '1'，则 dp[i][j] 的值由其上方、左方和左上方的 dp 值决定：

dp[i][j]=min(dp[i−1][j],dp[i][j−1],dp[i−1][j−1])+1

• 如果 matrix[i][j] 为 '0'，则 dp[i][j] = 0。

1. 最大边长记录：
   • 在填充 dp 数组的过程中，记录遇到的最大边长。

为了优化动态规划算法的执行速度，我们可以考虑以下几点：

1. 减少不必要的边界检查：在填充 dp 数组时，可以避免在循环中重复进行边界检查。
2. 空间优化：虽然空间优化不会直接影响时间复杂度，但可以减少内存访问的开销。
3. 循环展开：在某些情况下，循环展开可以减少循环控制的开销，但对于这个问题，可能不会有显著效果。

Java实现

class Solution {
    public int maximalSquare(char[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        int m = matrix.length;
        int n = matrix[0].length;
        int[] dp = new int[n + 1]; // 使用一维数组进行空间优化
        int maxSide = 0;
        int prev = 0; // 用于存储左上角的值

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int temp = dp[j + 1]; // 保存当前值，用于下一轮计算
                if (matrix[i][j] == '1') {
                    dp[j + 1] = Math.min(Math.min(dp[j], dp[j + 1]), prev) + 1;
                    maxSide = Math.max(maxSide, dp[j + 1]);
                } else {
                    dp[j + 1] = 0;
                }
                prev = temp; // 更新 prev 为当前位置的旧值
            }
            prev = 0; // 重置 prev，因为下一行的第一个元素没有左上角
        }
        return maxSide * maxSide;
    }
}

代码解释

1. 空间优化：
   • 使用一维数组 dp 代替二维数组，将空间复杂度从 O(m * n) 降低到 O(n)。
   • dp[j + 1] 存储当前行的值，prev 用于存储左上角的值。
2. 减少边界检查：
   • 在循环中，通过 prev 变量来存储左上角的值，避免重复访问 dp[i-1][j-1]。
3. 循环优化：
   • 通过提前保存 dp[j + 1] 的值到 temp，可以在下一次循环中直接使用，减少重复计算。

复杂度分析

• 时间复杂度：
  • O(m * n)，与之前相同，因为仍然需要遍历整个矩阵。
• 空间复杂度：
  • O(n)，通过使用一维数组进行空间优化。

简单总结

• 通过使用一维数组和减少不必要的边界检查，优化了算法的执行速度。
• 空间复杂度降低到 O(n)，同时保持了 O(m * n) 的时间复杂度。
• 代码在保持清晰的同时，提高了执行效率。