相关题型

问题一（最大和子矩阵） ： 有一个 m x n 的矩阵，矩阵的元素可正可负。请找出该矩阵的一个子矩阵（方块），使得其所有元素之和在所有子矩阵中最大。(问题来源：http://acm.pku.edu.cn/JudgeOnline/problem?id=1050）

问题二（ 最大 0/1 方块） ：有一个 m x n 的矩阵，元素为 0 或 1。一个子矩阵，如果它所有的元素都是 0， 或者都是 1，则称其为一个 0-聚类 或 1-聚类，统称聚类(Cluster)。请找出最大的聚类（元素最多的聚类）（面试题）

这两个问题，除了都是在矩阵上操作之外，似乎没有什么共同之处。其实不然。事实上，它们可以用同一个思路解决。该思路来源于下面的一个问题，具体地说，就是把前两个问题化归成多个问题三：

问题三（和最大的段） ：有 n 个有正有负的数排成一行，求某个连续的段，使得其元素之和最大。(问题来源：某面试题。事实上，这也是一道经典题目，具体参考 http://en.wikipedia.org/wiki/Maximum_subarray_problem)

问题四（最大长方形） ： 有一个有 n 个项的统计直方图，假定所有的直方条 (bar) 的宽度一样。在所有边与 x 轴 和 y 轴平行的长方形中，求该被该直方图包含的面积最大的长方形。（问题来源：面试经典题目）

参考

• Maximum Submatrix & Largest Rectangle
• [leetcode]221. Maximal Square

分析：动态规划，从左上角开始，如果当前位置为1，那么到当前位置包含的最大正方形边长为左/左上/上的值中的最小值加一，因为边长是由短板控制的。

• 最大子矩阵和

最大子矩阵和问题可以类比于最大字段和问题，从一维变成二维，dp思路，在输入的时候做一个处理，让a[i,j]变为存放前i行j列的和，降低复杂度。状态转移方程为sum[k+1]=sum[k]<0?0:sum[k]+a[i,j];表示第k行i到j的和。因为a[i,j]为存放前i行j列的和，所以a[i,j]=a[k,j]-a[k,i-1]; 

• Maximum sum rectangle in a 2D matrix | DP-27

// Program to find maximum sum subarray in a given 2D array
#include <stdio.h>
#include <string.h>
#include <limits.h>
#define ROW 4
#define COL 5
 
// Implementation of Kadane's algorithm for 1D array. The function 
// returns the maximum sum and stores starting and ending indexes of the 
// maximum sum subarray at addresses pointed by start and finish pointers 
// respectively.
int kadane(int* arr, int* start, int* finish, int n)
{
    // initialize sum, maxSum and
    int sum = 0, maxSum = INT_MIN, i;
 
    // Just some initial value to check for all negative values case
    *finish = -1;
 
    // local variable
    int local_start = 0;
 
    for (i = 0; i < n; ++i)
    {
        sum += arr[i];
        if (sum < 0)
        {
            sum = 0;
            local_start = i+1;
        }
        else if (sum > maxSum)
        {
            maxSum = sum;
            *start = local_start;
            *finish = i;
        }
    }
 
     // There is at-least one non-negative number
    if (*finish != -1)
        return maxSum;
 
    // Special Case: When all numbers in arr[] are negative
    maxSum = arr[0];
    *start = *finish = 0;
 
    // Find the maximum element in array
    for (i = 1; i < n; i++)
    {
        if (arr[i] > maxSum)
        {
            maxSum = arr[i];
            *start = *finish = i;
        }
    }
    return maxSum;
}
 
// The main function that finds maximum sum rectangle in M[][]
void findMaxSum(int M[][COL])
{
    // Variables to store the final output
    int maxSum = INT_MIN, finalLeft, finalRight, finalTop, finalBottom;
 
    int left, right, i;
    int temp[ROW], sum, start, finish;
 
    // Set the left column
    for (left = 0; left < COL; ++left)
    {
        // Initialize all elements of temp as 0
        memset(temp, 0, sizeof(temp));
 
        // Set the right column for the left column set by outer loop
        for (right = left; right < COL; ++right)
        {
           // Calculate sum between current left and right for every row 'i'
            for (i = 0; i < ROW; ++i)
                temp[i] += M[i][right];
 
            // Find the maximum sum subarray in temp[]. The kadane() 
            // function also sets values of start and finish.  So 'sum' is 
            // sum of rectangle between (start, left) and (finish, right) 
            //  which is the maximum sum with boundary columns strictly as
            //  left and right.
            sum = kadane(temp, &start, &finish, ROW);
 
            // Compare sum with maximum sum so far. If sum is more, then 
            // update maxSum and other output values
            if (sum > maxSum)
            {
                maxSum = sum;
                finalLeft = left;
                finalRight = right;
                finalTop = start;
                finalBottom = finish;
            }
        }
    }
 
    // Print final values
    printf("(Top, Left) (%d, %d)\n", finalTop, finalLeft);
    printf("(Bottom, Right) (%d, %d)\n", finalBottom, finalRight);
    printf("Max sum is: %d\n", maxSum);
}
 
// Driver program to test above functions
int main()
{
    int M[ROW][COL] = {{1, 2, -1, -4, -20},
                       {-8, -3, 4, 2, 1},
                       {3, 8, 10, 1, 3},
                       {-4, -1, 1, 7, -6}
                      };
 
    findMaxSum(M);
 
    return 0;
}