2023年12月20日-秋招-第三题（300分）-平面灯阵中寻找最大正方形边界

在线评测链接:P1657

本题考察的LeetCode原题

LeetCode 1139. 最大的以 1 为边界的正方形

题目描述

现在有一个二维数组来模拟一个黑白棋盘，将黑白棋子置于方格之中，棋盘中每个位置都放入黑棋或白棋，分别对应数组每个元素取值只能为 $1$ 或 $0$ （黑棋为 $1$ , 白棋为 $0$），现在需要找一个正方形边界，其每条边上的棋子都是黑棋(对应数组中元素的值为 $1$ )的，且该正方形面积最大。

输入描述

输入第一行为棋盘的行数(二维数组的行数)

输入第二行为棋盘的列数(二维数组的列数)

紧接着为模拟棋盘的二维数组 $arr$

$1<arr.length\le 200$

$1<arr[0].length\le 200$

输出描述

返回满足条件的面积最大正方形边界信息。返回信息[$r,c,w$],其中 $r$ , $c$ 分别代表方阵右下角的行号和列号，$w$ 代表正方形的宽度。如果存在多个满足条件的正方形，则返回 $r$ 最小的，若 $r$ 相同，返回 $c$ 最小的正方形。

样例1

输入

4
5
1 0 0 0 1
1 1 1 1 1
1 0 1 1 0
1 1 1 1 1

输出

[3,2,3]

说明：满足条件且面积最大的正方形边界，其右下角的顶点为 [3,2]，即行号为 $3$ ，列好为 $2$ ，其宽度为 $3$ ，因此返回信息为 [$3,2,3$]。

样例2

输入

3
3
1 0 0
0 1 0
0 0 1

输出

[0,0,1]

**说明：**满足条件且面积最大的正方形边界有三个。即为 [$0,0,1$]、[$1,1,1$]、[$2,2,1$]，根据要求，如果满足条件有多个，则返回 $r$ 最小，即为[$0,0,1$]

思路：动态规划/前缀和

原题来自于LeetCode 1139. 最大的以 1 为边界的正方形

我们只需要在此基础上找到这个正方形的右下角即可。

由于题目数据大为$200$ , 所以$O(n^3)$ 可过。那么就有非常多的做法(参考leetcode题解)。*下面给出的是一种前缀和差分的做法:*

枚举右下角，再枚举对角线。这样我们就用$O(n^3)$的复杂度枚举出了所有可能的正方形。

然后我们只需要差分求这个正方形 减去 内部小正方形的和。这样就得到了边界上的值的和。看他是不是(边长 - 1) * 4 即可。

时间复杂度

$O(n^3)$

代码

C++

#include<bits/stdc++.h>
using namespace std;
int dp[205][205];
class Solution {
public:
    inline int ask(int x , int y , int a , int b){
        return dp[a][b] - dp[a][y - 1] - dp[x - 1][b] + dp[x - 1][y - 1];
    }
    vector<int> largest1BorderedSquare(vector< vector<int> >& a) {
        int n = a.size() , m = a[0].size() , sum = 0 , i , j , k;
        for (i = 1 ; i <= n ; i++){
            for (j = 1 ; j <= m ; j++){
                int v = a[i - 1][j - 1];
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + v; 
                sum += v;
            }
        }
        if (!sum) return {0,0,0};
        int ans = 1 , len;
        int r = 1e9 , c = 1e9;
        for (i = n ; i >= 1 ; i--){
            for (j = m ; j >= 1 ; j--){
                len = min(i , j);
                for (k = ans ; k <= len ; k++){
                    if (ask( i - k + 1 , j - k + 1 , i , j) - ask(i - k + 2 , j - k + 2 , i - 1 , j - 1 ) == 4 * (k - 1)){
                        if (ans < k){
                            ans = k;
                            r = i;
                            c = j;
                        }else if (ans == k){
                            if (i < r){
                                r = i;
                                c = j;
                            }else if (i == r){
                                if (j < c){
                                    c = j;
                                }
                            }
                        }
                    }

                }
            }
        }
        return {r , c , ans};
    }
};

int main (){
    int n;
    int m;
    cin >> n;
    cin >> m;
    Solution sol;
    vector< vector<int> > a(n , vector<int>(n));
    for (int i = 0 ; i < n ; i++){
        for (int j = 0 ; j < m ; j++){
            cin >> a[i][j];
        }
    }
    vector<int> res = sol.largest1BorderedSquare(a);
    cout << "[" << res[0] - 1 << "," << res[1] - 1 << "," << res[2] << "]" << endl;
    return 0;
}

python代码

def ask(x, y, a, b, dp):
    return dp[a][b] - dp[a][y - 1] - dp[x - 1][b] + dp[x - 1][y - 1]

def largest1BorderedSquare(a):
    n = len(a)
    m = len(a[0])
    dp = [[0] * (m + 1) for _ in range(n + 1)]
    sum = 0
    for i in range(1, n + 1):
        for j in range(1, m + 1):
            v = a[i - 1][j - 1]
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + v
            sum += v
    if sum == 0:
        return [0, 0, 0]
    ans = 1
    r = float('inf')
    c = float('inf')
    for i in range(n, 0, -1):
        for j in range(m, 0, -1):
            length = min(i, j)
            for k in range(ans, length + 1):
                if ask(i - k + 1, j - k + 1, i, j, dp) - ask(i - k + 2, j - k + 2, i - 1, j - 1, dp) == 4 * (k - 1):
                    if ans < k:
                        ans = k
                        r = i
                        c = j
                    elif ans == k:
                        if i < r:
                            r = i
                            c = j
                        elif i == r:
                            if j < c:
                                c = j
    return [r, c, ans]

n = int(input())
m = int(input())
a = []
for _ in range(n):
    a.append(list(map(int, input().split())))
res = largest1BorderedSquare(a)
print("[{},{},{}]".format(res[0] - 1, res[1] - 1, res[2]))

Java代码

import java.util.*;

public class Main {
    private static int[][] dp;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[][] a = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                a[i][j] = scanner.nextInt();
            }
        }
        int[] res = largest1BorderedSquare(a);
        System.out.println("[" + (res[0] - 1) + "," + (res[1] - 1) + "," + res[2] + "]");
    }

    public static int[] largest1BorderedSquare(int[][] a) {
        int n = a.length, m = a[0].length, sum = 0;
        dp = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                int v = a[i - 1][j - 1];
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + v;
                sum += v;
            }
        }
        if (sum == 0) return new int[]{0, 0, 0};
        int ans = 1, len, r = Integer.MAX_VALUE, c = Integer.MAX_VALUE;
        for (int i = n; i >= 1; i--) {
            for (int j = m; j >= 1; j--) {
                len = Math.min(i, j);
                for (int k = ans; k <= len; k++) {
                    if (ask(i - k + 1, j - k + 1, i, j) - ask(i - k + 2, j - k + 2, i - 1, j - 1) == 4 * (k - 1)) {
                        if (ans < k) {
                            ans = k;
                            r = i;
                            c = j;
                        } else if (ans == k) {
                            if (i < r) {
                                r = i;
                                c = j;
                            } else if (i == r) {
                                if (j < c) {
                                    c = j;
                                }
                            }
                        }
                    }
                }
            }
        }
        return new int[]{r, c, ans};
    }

    private static int ask(int x, int y, int a, int b) {
        return dp[a][b] - dp[a][y - 1] - dp[x - 1][b] + dp[x - 1][y - 1];
    }
}