打印给定大小的最大平方和子矩阵

给定一个 N x N 矩阵，找到 k <= N 且 k >= 1 的 akxk 子矩阵，使得子矩阵中所有元素的总和最大。输入矩阵可以包含零、正数和负数。
例如考虑下面的矩阵，如果 k = 3，那么输出应该打印用蓝色包围的子矩阵。

我们强烈建议您最小化您的浏览器并首先自己尝试。
一个简单的解决方案是在我们的输入矩阵中考虑所有可能的大小为 kxk 的子平方，并找到具有最大和的子平方。上述解决方案的时间复杂度为 O(N ² k ² )。
我们可以在 O(N ² ) 时间内解决这个问题。这个问题主要是这个打印所有总和的问题的扩展。这个想法是预处理给定的方阵。在预处理步骤中，计算临时方阵 stripSum[][] 中所有大小为 kx 1 的垂直条带的总和。一旦我们得到所有垂直条的总和，我们可以将一行中的第一个子正方形的总和计算为该行中前 k 个条的总和，对于剩余的子正方形，我们可以在 O(1) 时间内通过删除来计算总和前一个子正方形的最左边的条带并添加新正方形的最右边的条带。
下面是上述想法的实现。

C++

// An efficient C++ program to find maximum sum
// sub-square matrix
#include 
using namespace std;
 
// Size of given matrix
#define N 5
 
// A O(n^2) function to the maximum sum sub-
// squares of size k x k in a given square
// matrix of size n x n
void printMaxSumSub(int mat[][N], int k)
{
    // k must be smaller than or equal to n
    if (k > N) return;
 
    // 1: PREPROCESSING
    // To store sums of all strips of size k x 1
    int stripSum[N][N];
 
    // Go column by column
    for (int j=0; j max_sum)
        {
            max_sum = sum;
            pos = &(mat[i][0]);
        }
 
        // Calculate sum of remaining squares in
        // current row by removing the leftmost
        // strip of previous sub-square and adding
        // a new strip
        for (int j=1; j max_sum)
            {
                max_sum = sum;
                pos = &(mat[i][j]);
            }
        }
    }
 
    // Print the result matrix
    for (int i=0; i

---

Java

// An efficient Java program to find maximum sum
// sub-square matrix
 
// Class to store the position of start of
// maximum sum in matrix
class Position {
    int x;
    int y;
 
    // Constructor
    Position(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    // Updates the position if new maximum sum
    // is found
    void updatePosition(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    // returns the current value of X
    int getXPosition() {
        return this.x;
    }
 
    // returns the current value of y
    int getYPosition() {
        return this.y;
    }
}
 
class Gfg {
    // Size of given matrix
    static int N;
 
    // A O(n^2) function to the maximum sum sub-
    // squares of size k x k in a given square
    // matrix of size n x n
    static void printMaxSumSub(int[][] mat, int k) {
 
        // k must be smaller than or equal to n
        if (k > N)
            return;
 
        // 1: PREPROCESSING
        // To store sums of all strips of size k x 1
        int[][] stripSum = new int[N][N];
 
        // Go column by column
        for (int j = 0; j < N; j++) {
 
            // Calculate sum of first k x 1 rectangle
            // in this column
            int sum = 0;
            for (int i = 0; i < k; i++)
                sum += mat[i][j];
            stripSum[0][j] = sum;
 
            // Calculate sum of remaining rectangles
            for (int i = 1; i < N - k + 1; i++) {
                sum += (mat[i + k - 1][j] - mat[i - 1][j]);
                stripSum[i][j] = sum;
            }
        }
 
        // max_sum stores maximum sum and its
        // position in matrix
        int max_sum = Integer.MIN_VALUE;
        Position pos = new Position(-1, -1);
 
        // 2: CALCULATE SUM of Sub-Squares using stripSum[][]
        for (int i = 0; i < N - k + 1; i++) {
 
            // Calculate and print sum of first subsquare
            // in this row
            int sum = 0;
            for (int j = 0; j < k; j++)
                sum += stripSum[i][j];
 
            // Update max_sum and position of result
            if (sum > max_sum) {
                max_sum = sum;
                pos.updatePosition(i, 0);
            }
 
            // Calculate sum of remaining squares in
            // current row by removing the leftmost
            // strip of previous sub-square and adding
            // a new strip
            for (int j = 1; j < N - k + 1; j++) {
                sum += (stripSum[i][j + k - 1] - stripSum[i][j - 1]);
 
                // Update max_sum and position of result
                if (sum > max_sum) {
                    max_sum = sum;
                    pos.updatePosition(i, j);
                }
            }
        }
 
        // Print the result matrix
        for (int i = 0; i < k; i++) {
            for (int j = 0; j < k; j++) {
                System.out.print(mat[i + pos.getXPosition()][j + pos.getYPosition()] + " ");
            }
            System.out.println();
        }
    }
 
    // Driver program to test above function
    public static void main(String[] args) {
        N = 5;
        int[][] mat = { { 1, 1, 1, 1, 1 },
                { 2, 2, 2, 2, 2 },
                { 3, 8, 6, 7, 3 },
                { 4, 4, 4, 4, 4 },
            { 5, 5, 5, 5, 5 } };
    int k = 3;
 
        System.out.println("Maximum sum 3 x 3 matrix is");
        printMaxSumSub(mat, k);
    }
}
 
// This code is contributed by Vivek Kumar Singh

Python3

# An efficient Python3 program to find maximum sum
# sub-square matrix
 
# Size of given matrix
N = 5
 
# A O(n^2) function to the maximum sum sub-
# squares of size k x k in a given square
# matrix of size n x n
def printMaxSumSub(mat, k):
 
    # k must be smaller than or equal to n
    if (k > N):
        return;
 
    # 1: PREPROCESSING
    # To store sums of all strips of size k x 1
    stripSum = [[0 for j in range(N)] for i in range(N)];
 
    # Go column by column
    for j in range(N):
         
        # Calculate sum of first k x 1 rectangle
        # in this column
        sum = 0;
        for i in range(k):
            sum += mat[i][j];
        stripSum[0][j] = sum;
 
        # Calculate sum of remaining rectangles
        for i in range(1,N-k+1):
            sum += (mat[i+k-1][j] - mat[i-1][j]);
            stripSum[i][j] = sum;
 
    # max_sum stores maximum sum and its
    # position in matrix
    max_sum = -1000000000
    i_ind = 0
    j_ind = 0
 
    # 2: CALCULATE SUM of Sub-Squares using stripSum[][]
    for i in range(N-k+1):
         
        # Calculate and print sum of first subsquare
        # in this row
        sum = 0;
        for j in range(k):
            sum += stripSum[i][j];
 
        # Update max_sum and position of result
        if (sum > max_sum):
            max_sum = sum;
            i_ind = i
            j_ind = 0
 
 
        # Calculate sum of remaining squares in
        # current row by removing the leftmost
        # strip of previous sub-square and adding
        # a new strip
        for j in range(1,N-k+1):
            sum += (stripSum[i][j+k-1] - stripSum[i][j-1]);
 
            # Update max_sum and position of result
            if (sum > max_sum):
                max_sum = sum;
                i_ind = i
                j_ind = j
 
    # Print the result matrix
    for i in range(k):
        for j in range(k):
            print(mat[i+i_ind][j+j_ind], end = ' ')
        print()
 
# Driver program to test above function
mat = [[1, 1, 1, 1, 1],
        [2, 2, 2, 2, 2],
        [3, 8, 6, 7, 3],
        [4, 4, 4, 4, 4],
        [5, 5, 5, 5, 5],
    ];
k = 3;
print("Maximum sum 3 x 3 matrix is");
printMaxSumSub(mat, k);
 
# This code is contributed by rutvik_56.

C#

// An efficient C# program to find maximum sum
// sub-square matrix
using System;
 
// Class to store the position of start of
// maximum sum in matrix
class Position
{
    int x;
    int y;
 
    // Constructor
    public Position(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
 
    // Updates the position if new maximum sum
    // is found
    public void updatePosition(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
 
    // returns the current value of X
    public int getXPosition()
    {
        return this.x;
    }
 
    // returns the current value of y
    public int getYPosition()
    {
        return this.y;
    }
}
 
class GFG
{
     
    // Size of given matrix
    static int N;
 
    // A O(n^2) function to the maximum sum sub-
    // squares of size k x k in a given square
    // matrix of size n x n
    static void printMaxSumSub(int[,] mat, int k)
    {
 
        // k must be smaller than or equal to n
        if (k > N)
            return;
 
        // 1: PREPROCESSING
        // To store sums of all strips of size k x 1
        int[,] stripSum = new int[N, N];
 
        // Go column by column
        for (int j = 0; j < N; j++)
        {
 
            // Calculate sum of first k x 1 rectangle
            // in this column
            int sum = 0;
            for (int i = 0; i < k; i++)
                sum += mat[i, j];
            stripSum[0, j] = sum;
 
            // Calculate sum of remaining rectangles
            for (int i = 1; i < N - k + 1; i++)
            {
                sum += (mat[i + k - 1, j] -
                        mat[i - 1, j]);
                stripSum[i, j] = sum;
            }
        }
 
        // max_sum stores maximum sum and its
        // position in matrix
        int max_sum = int.MinValue;
        Position pos = new Position(-1, -1);
 
        // 2: CALCULATE SUM of Sub-Squares using stripSum[,]
        for (int i = 0; i < N - k + 1; i++)
        {
 
            // Calculate and print sum of first subsquare
            // in this row
            int sum = 0;
            for (int j = 0; j < k; j++)
                sum += stripSum[i, j];
 
            // Update max_sum and position of result
            if (sum > max_sum)
            {
                max_sum = sum;
                pos.updatePosition(i, 0);
            }
 
            // Calculate sum of remaining squares in
            // current row by removing the leftmost
            // strip of previous sub-square and adding
            // a new strip
            for (int j = 1; j < N - k + 1; j++)
            {
                sum += (stripSum[i, j + k - 1] -
                        stripSum[i, j - 1]);
 
                // Update max_sum and position of result
                if (sum > max_sum)
                {
                    max_sum = sum;
                    pos.updatePosition(i, j);
                }
            }
        }
 
        // Print the result matrix
        for (int i = 0; i < k; i++)
        {
            for (int j = 0; j < k; j++)
            {
                Console.Write(mat[i + pos.getXPosition(),
                                  j + pos.getYPosition()] + " ");
            }
            Console.WriteLine();
        }
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        N = 5;
        int[,] mat = {{ 1, 1, 1, 1, 1 },
                      { 2, 2, 2, 2, 2 },
                        { 3, 8, 6, 7, 3 },
                      { 4, 4, 4, 4, 4 },
                      { 5, 5, 5, 5, 5 }};
        int k = 3;
 
        Console.WriteLine("Maximum sum 3 x 3 matrix is");
        printMaxSumSub(mat, k);
    }
}
 
// This code is contributed by Princi Singh

Javascript

 
// An efficient Javascript program to find maximum sum
// sub-square matrix
 
// Class to store the position of start of
// maximum sum in matrix
class Position
{
    constructor()
    {
        this.x = 0;
        this.y = 0;
    }
 
    // Constructor
    Position(x, y)
    {
        this.x = x;
        this.y = y;
    }
 
    // Updates the position if new maximum sum
    // is found
    updatePosition(x, y)
    {
        this.x = x;
        this.y = y;
    }
 
    // returns the current value of X
    getXPosition()
    {
        return this.x;
    }
 
    // returns the current value of y
    getYPosition()
    {
        return this.y;
    }
}
 
// Size of given matrix
var N = 0;
// A O(n^2) function to the maximum sum sub-
// squares of size k x k in a given square
// matrix of size n x n
function printMaxSumSub(mat, k)
{
    // k must be smaller than or equal to n
    if (k > N)
        return;
    // 1: PREPROCESSING
    // To store sums of all strips of size k x 1
    var stripSum = Array.from(Array(N), ()=>Array(N));
    // Go column by column
    for (var j = 0; j < N; j++)
    {
        // Calculate sum of first k x 1 rectangle
        // in this column
        var sum = 0;
        for (var i = 0; i < k; i++)
            sum += mat[i][j];
        stripSum[0][j] = sum;
        // Calculate sum of remaining rectangles
        for (var i = 1; i < N - k + 1; i++)
        {
            sum += (mat[i + k - 1][j] -
                    mat[i - 1][j]);
            stripSum[i][j] = sum;
        }
    }
    // max_sum stores maximum sum and its
    // position in matrix
    var max_sum = -1000000000;
    var pos = new Position(-1, -1);
    // 2: CALCULATE SUM of Sub-Squares using stripSum[,]
    for (var i = 0; i < N - k + 1; i++)
    {
        // Calculate and print sum of first subsquare
        // in this row
        var sum = 0;
        for (var j = 0; j < k; j++)
            sum += stripSum[i][j];
        // Update max_sum and position of result
        if (sum > max_sum)
        {
            max_sum = sum;
            pos.updatePosition(i, 0);
        }
        // Calculate sum of remaining squares in
        // current row by removing the leftmost
        // strip of previous sub-square and adding
        // a new strip
        for (var j = 1; j < N - k + 1; j++)
        {
            sum += (stripSum[i][j + k - 1] -
                    stripSum[i][j - 1]);
            // Update max_sum and position of result
            if (sum > max_sum)
            {
                max_sum = sum;
                pos.updatePosition(i, j);
            }
        }
    }
    // Print the result matrix
    for (var i = 0; i < k; i++)
    {
        for (var j = 0; j < k; j++)
        {
            document.write(mat[i + pos.getXPosition()][
                              j + pos.getYPosition()] + " ");
        }
        document.write("<br>");
    }
}
// Driver Code
N = 5;
var mat = [[ 1, 1, 1, 1, 1 ],
              [ 2, 2, 2, 2, 2 ],
                [ 3, 8, 6, 7, 3 ],
              [ 4, 4, 4, 4, 4 ],
              [ 5, 5, 5, 5, 5 ]];
var k = 3;
document.write("Maximum sum 3 x 3 matrix is<br>");
printMaxSumSub(mat, k);
 
 
 

输出：

Maximum sum 3 x 3 matrix is
8 6 7
4 4 4
5 5 5