[Swift]LeetCode1139. 最大的以 1 为边界的正方形 | Largest 1-Bordered Square

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/11258432.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a 2D grid of 0s and 1s, return the number of elements in the largest square subgrid that has all 1s on its border, or 0 if one doesn't exist. 

Example 1:

Input: grid = [[1,1,1],[1,0,1],[1,1,1]]
Output: 9

Example 2:

Input: grid = [[1,1,0,0]]
Output: 1 

Constraints:

• 1 <= grid.length <= 100
• 1 <= grid[0].length <= 100
• grid[i][j] is 0 or 1

---

给你一个由若干 0 和 1 组成的二维网格 grid，请你找出边界全部由 1 组成的最大 正方形 子网格，并返回该子网格中的元素数量。如果不存在，则返回 0。 

示例 1：

输入：grid = [[1,1,1],[1,0,1],[1,1,1]]
输出：9

示例 2：

输入：grid = [[1,1,0,0]]
输出：1 

提示：

• 1 <= grid.length <= 100
• 1 <= grid[0].length <= 100
• grid[i][j] 为 0 或 1

---

Runtime: 100 ms

Memory Usage: 21 MB

class Solution {
    func largest1BorderedSquare(_ grid: [[Int]]) -> Int {
        var naxNum:Int = 0
        let m:Int = grid.count
        let n:Int = grid[0].count
        var hor:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:n),count:m)
        var ver:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:n),count:m)
        for i in 0..<m
        {
            for j in 0..<n
            {
                if grid[i][j] == 1
                {
                    // auxillary horizontal array
                    hor[i][j] = (j == 0) ? 1 : hor[i][j-1] + 1 
                    // auxillary vertical array
                    ver[i][j] = (i == 0) ? 1 : ver[i-1][j] + 1
                }
            }            
        }
        for i in stride(from:m - 1,through:0,by:-1)
        {
            for j in stride(from:n - 1,through:0,by:-1)
            {
                // choose smallest of horizontal and vertical value
                var small:Int = min(hor[i][j], ver[i][j])
                while (small > naxNum)
                {
                    // check if square exists with 'small' length
                    if ver[i][j-small+1] >= small &&  hor[i-small+1][j] >= small
                    {
                        naxNum = small
                    }
                    small -= 1
                }
            }
        }
        return naxNum * naxNum
    }
}

---

104ms

class Solution {
    private func checkBottomRight(_ grid: [[Int]], row: Int, col: Int, length: Int) -> Bool {
        guard length > 1 else {
            return true
        }
        
        for i in 0..<length {
            if grid[row + i][col + length - 1] != 1 || grid[row + length - 1][col + i] != 1 {
                return false
            }
        }
        return true
    }
    
    func largest1BorderedSquare(_ grid: [[Int]]) -> Int {
        var maxLength = 0
        for row in 0..<grid.count {
            for col in 0..<grid[row].count {
                guard grid[row][col] == 1 else {
                    continue
                }
                
                var i = 1
                while row + i < grid.count && grid[row + i][col] == 1 && col + i < grid[row].count && grid[row][col + i] == 1 {
                    i += 1
                }
                while i > maxLength && !self.checkBottomRight(grid, row: row, col: col, length: i) {
                    i -= 1
                }
                maxLength = Swift.max(maxLength, i)
            }
        }
        return maxLength * maxLength
    }
}

---

120ms

class Solution {
    
    func largest1BorderedSquare(_ grid: [[Int]]) -> Int {
        var  ans = 0
        let rowSize = grid.count
        let colSize = grid[0].count
        
        func valid(x: Int,y: Int, edgeLength: Int) -> Bool {
            let lastY = y + edgeLength - 1
            let lastX =  x + edgeLength - 1
            for i in x...lastX {
                if grid[i][y] == 0 || grid[i][lastY] == 0{
                    return false
                }
            }
            for j in y...lastY {
                if grid[x][j] == 0 || grid[lastX][j] == 0  {
                    return false
                }
            }
            return true
        }
        for i in 0..<rowSize {
            for j in 0..<colSize {
                if grid[i][j] == 1 {
                    if ans == 0 {
                        ans = 1
                    }
                    if i != rowSize - 1 && j != colSize - 1 {
                        //---->right
                        var m = j + 1
                        while m < colSize && grid[i][m] == 1 {
                            m += 1
                        }
                        var n = i + 1
                        while n < rowSize &&  grid[n][j] == 1 {
                            n += 1
                        }
                        var squreLength = min(n - i, m - j)
                        while squreLength > ans {
                            if valid(x: i, y: j, edgeLength: squreLength) {
                                ans = squreLength
                            }
                            squreLength -= 1
                        }
                    }
                }
            }
        }
        return ans * ans
    }
}

---

124 ms

class Solution {
    func largest1BorderedSquare(_ grid: [[Int]]) -> Int {
        guard !grid.isEmpty, !grid[0].isEmpty else { return 0 }
        
        let m = grid.count
        let n = grid[0].count
        var horizontal = Array(repeating: Array(repeating: 0, count: n), count: m)
        var vertical = Array(repeating: Array(repeating: 0, count: n), count: m)
        
        for i in 0..<m {
            for j in 0..<n {
                if grid[i][j] > 0 {
                    horizontal[i][j] = j == 0 ? 1 : horizontal[i][j-1] + 1
                    vertical[i][j] = i == 0 ? 1 : vertical[i-1][j] + 1   
                }
            }
        }
        
        for l in (1...min(m,n)).reversed() {
            for i in (0..<m-l+1) {
                for j in (0..<n-l+1) {
                    if vertical[i+l-1][j] >= l, vertical[i+l-1][j+l-1] >= l,
                       horizontal[i][j+l-1] >= l, horizontal[i+l-1][j+l-1] >= l {
                           return l * l
                    }
                }
            }
        }
        
        return 0
    } 
}

---

244ms

class Solution {
    func largest1BorderedSquare(_ grid: [[Int]]) -> Int {
        let M = grid.count
        let N = grid[0].count
        var left = [[Int]](repeating:[Int](repeating:0, count: N), count: M)
        var top = [[Int]](repeating:[Int](repeating:0, count: N), count: M)
        for i in grid.indices {
            for j in grid[0].indices {
                if grid[i][j] == 1{
                    left[i][j] = j > 0 ? left[i][j-1] + 1 : 1
                    top[i][j] = i > 0 ? top[i-1][j] + 1 : 1
                }
            }
        }
        for l in stride(from: min(M, N), to: 0, by: -1) {
            for i in stride(from: 0, to: M - l + 1, by: 1) {
                for j in stride(from: 0, to: N - l + 1, by: 1) {
                    if top[i + l - 1][j] >= l
                    && top[i + l - 1][j + l - 1] >= l
                    && left[i][j + l - 1] >= l
                    && left[i + l - 1][j + l - 1] >= l {
                        return l * l
                    }
                }
            }
        }
        return 0
    }
}