矩阵的任何矩形的最大和不超过 K

简介

给定一个二维矩阵和一个整数 K，找出该矩阵中任意矩形区域的元素和的最大值，该最大值不超过 K。

这是一道经典的动态规划问题，也可以使用优先队列来解决。下面将分别介绍两种解法。

动态规划

算法说明

假设矩阵的左上角为(0, 0)，右下角为(r-1, c-1)，矩形区域的左上角为(i, j)，右下角为(k, l)。那么矩形区域的元素和可以表示为：

sum[i][j][k][l] = sum[i][j][k-1][l] + sum[i][j][k][l-1] - sum[i][j][k-1][l-1] + matrix[k][l]

其中，sum[i][j][k][l]表示从(i, j)到(k, l)的矩形区域的元素和，matrix[k][l]表示矩形区域右下角的元素。

那么，矩形区域的最大和不超过 K，则有：

sum[i][j][k][l] - sum[i][j][k-1][l] - sum[i][j][k][l-1] + sum[i][j][k-1][l-1] <= K

转换成以下等式：

sum[i][j][k][l] <= sum[i][j][k-1][l] + sum[i][j][k][l-1] - sum[i][j][k-1][l-1] + K

由此，可以通过动态规划解决该问题。

代码

def max_sum_submatrix(matrix, k):
    m, n = len(matrix), len(matrix[0])
    result = float('-inf')
    for i in range(m):
        for j in range(n):
            for k in range(i, m):
                for l in range(j, n):
                    sum_ijkl = 0
                    if i == 0 and j == 0:
                        sum_ijkl = matrix[k][l]
                    elif i == 0:
                        sum_ijkl = sum(matrix[x][l] for x in range(i, k+1))
                    elif j == 0:
                        sum_ijkl = sum(matrix[k][x] for x in range(j, l+1))
                    else:
                        sum_ijkl = sum(matrix[x][y] for x in range(i, k+1) for y in range(j, l+1))

                    if sum_ijkl <= k:
                        result = max(result, sum_ijkl)

    return result

优先队列

算法说明

首先，将矩阵按行累加求和，将原问题转化为求每个行的任意子段的和不超过 K 的最大值。

假设有两个行 i 和 j，它们的前缀和分别为 sum_i 和 sum_j。若 sum_i <= sum_j，则对于任意以 i 为起点的子段，其结尾在 j 或者 j 右侧，才可能具有最大值。

因此，对于每个行 i，可以维护一个有序数组 prev_sum，其中 prev_sum[j] 表示前 j 个行的前缀和的最小值，以此找到第一个满足 sum_i - prev_sum[j] <= K 的 j 值，从而求得以 i 结尾的最大子段和。

时间复杂度为 O(min(r,c)^2 * max(r,c) * log(max(r,c)))。

代码

import bisect

def max_sum_submatrix(matrix, k):
    m, n = len(matrix), len(matrix[0])
    result = float('-inf')
    for i in range(m):
        sums = [0] * n
        for j in range(i, m):
            for p in range(n):
                sums[p] += matrix[j][p]
            
            sorted_sums = [0]
            cur_sum = 0
            for sum_p in sums:
                cur_sum += sum_p
                idx = bisect.bisect_left(sorted_sums, cur_sum - k)
                if idx < len(sorted_sums):
                    result = max(result, cur_sum - sorted_sums[idx])
                bisect.insort(sorted_sums, cur_sum)

    return result

总结

本篇文章介绍了两种解决最大子段和问题的方法：动态规划和优先队列。不同的方法适用于不同的场景，需要具体分析问题。