[Swift]LeetCode695. 岛屿的最大面积 | Max Area of Island

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

Given a non-empty 2D array grid of 0's and 1's, an island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.

Find the maximum area of an island in the given 2D array. (If there is no island, the maximum area is 0.)

Example 1:

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]

Given the above grid, return 6. Note the answer is not 11, because the island must be connected 4-directionally.

Example 2:

[[0,0,0,0,0,0,0,0]]

Given the above grid, return 0.

Note: The length of each dimension in the given grid does not exceed 50.

---

给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)

示例 1:

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]

对于上面这个给定矩阵应返回 6。注意答案不应该是11，因为岛屿只能包含水平或垂直的四个方向的‘1’。

示例 2:

[[0,0,0,0,0,0,0,0]]

对于上面这个给定的矩阵, 返回 0。

注意: 给定的矩阵grid 的长度和宽度都不超过 50。

---

Runtime: 76 ms

Memory Usage: 20 MB

class Solution {
    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
        var tempGrid = grid
        var area = 0
        let m = tempGrid.count
        var n = 0
        var islandMax = 0
        for i in 0..<m {
            n = tempGrid[i].count
            for j in 0..<n {
                area = 0
                area = dfs(i, j, m, n, &tempGrid, &area)
                islandMax = max(islandMax, area)
            }
        }
        return islandMax    
    }
    
    func dfs(_ i: Int,_ j: Int,_ m: Int,_ n:Int,_ grid: inout [[Int]],_ tempArea: inout Int) -> Int {
        if i<0 || i>=m || j<0 || j>=n || grid[i][j] == 0 {
            return tempArea
        }
        grid[i][j] = 0
        tempArea += 1
        tempArea = dfs(i+1, j, m, n, &grid, &tempArea)
        tempArea = dfs(i-1, j, m, n, &grid, &tempArea)
        tempArea = dfs(i, j+1, m, n, &grid, &tempArea)
        tempArea = dfs(i, j-1, m, n, &grid, &tempArea)
        return tempArea
    }
}

---

80ms

class Solution {
    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
        var dp:[[Int]] = grid
        var mX: Int = 0
        
        for i in 0 ..< dp.count {
            for j in 0 ..< dp[0].count {
                // print("i:(i) j:(j)")
                if dp[i][j] == 1 {
                    mX = max(mX, area(&dp,i,j))
                }
            }
        }
        
        return mX
    }
    
    func area(_ dp: inout [[Int]], _ i:Int, _ j:Int) -> Int {
        if i < dp.count && i >= 0 && j < dp[0].count && j >= 0 && dp[i][j] == 1 {
            dp[i][j] = 0
            return 1 + area(&dp, i-1, j) + area(&dp, i+1, j) + area(&dp, i, j-1) + area(&dp, i, j+1)
        }
        return 0
    }
}

---

92ms

class Solution {
    var height = 0
    var width = 0
    
    var grid: [[Int]]!
    var visited: [[Bool]]!
    
    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
        height = grid.count
        width = grid[0].count
        
        self.grid = grid
        
        var maxSize = 0
        visited = Array(repeating:Array(repeating: false, count: width), count: height)
        
        for y in 0..<grid.count {
            for x in 0..<grid[0].count {
                if grid[y][x] == 1 && visited[y][x] == false {
                    let size = visitIsland(x: x, y: y)
                    if size > maxSize {
                        maxSize = size
                    }
                }
            }
        }
        return maxSize
    }
    
    
    func visitIsland(x: Int, y: Int) -> Int {
     //   print("visit island x: (x) y: (y)")
        if x < 0 || y < 0 || x >= width || y >= height {
            return 0
        }
        if grid[y][x] == 0 || visited[y][x] == true {
            return 0
        }
        visited[y][x] = true
        var size = 1
        size = size + visitIsland(x: x-1, y: y)
        size = size + visitIsland(x: x+1, y: y)
        size = size + visitIsland(x: x, y: y-1)
        size = size + visitIsland(x: x, y: y+1)
        return size
    }
}

---

108ms

class Solution {
    var maxCount = 0
    let transform = [[0,1],[0,-1],[1,0],[-1,0]]
    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
        var grid = grid
        for i in 0..<grid.count {
            for j in 0..<grid[0].count {
                if grid[i][j] == 1 {
                    let count = dfs(&grid, i, j)
                    if maxCount < count {
                        maxCount = count 
                    }
                }
            }
        }
        return maxCount
    }
    
    func dfs(_ grid: inout [[Int]], _ x: Int, _ y: Int) -> Int {
        if x >= 0 && x < grid.count && y >= 0 && y < grid[0].count && grid[x][y] == 1 {
            grid[x][y] = 0
            var count = 1
            for i in 0..<4 {
                let xx = x + transform[i][0]
                let yy = y + transform[i][1]
                count = count + dfs(&grid, xx, yy)
            }   
            return count
        } else {
            return 0
        }
    }
}

---

108ms

class Solution {
    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
  var maxArea = 0
  var grid = grid
  for i in 0..<grid.count {
    for j in 0..<grid[i].count {
      if grid[i][j] == 1 {
        maxArea = max(maxArea, area(&grid, i, j))
      }
    }
  }
  return maxArea
}

func area(_ grid:inout[[Int]], _ i: Int, _ j: Int) -> Int {
  var size = 0
  if(i>=0 && i<grid.count && j>=0 && j<grid[0].count && grid[i][j]==1) {
    grid[i][j] = 0
    size = 1 + 
    area(&grid, i+1, j) + 
    area(&grid, i-1, j) + 
    area(&grid, i, j-1) + 
    area(&grid, i, j+1)
  }
  return size
}
}

---

112ms

class Solution {
    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
        if grid.isEmpty || grid[0].isEmpty { return 0 }
        var res = 0
        var grid = grid
        let m = grid.count, n = grid[0].count
        for i in 0..<m {
            for j in 0..<n {
                if grid[i][j] == 0 { continue }
                var count = 0
                var worklist = [(i, j)]
                while !worklist.isEmpty {
                    let (x, y) = worklist.popLast()!
                    if grid[x][y] == 0 { continue }
                    grid[x][y] = 0
                    count += 1
                    if x > 0  { worklist.append((x - 1, y)) }
                    if y > 0 { worklist.append((x, y - 1)) }
                    if x < m - 1 { worklist.append((x + 1, y)) }
                    if y < n - 1 { worklist.append((x, y + 1)) }
                }
                res = max(res, count)
            }
        }
        return res
    }
}

---

132 ms

class Solution {
    var dirs:[[Int]] = [[0,-1],[-1,0],[0,1],[1,0]]
    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
        var grid = grid
        var m:Int = grid.count
        var n:Int = grid[0].count
        var res:Int = 0
        for i in 0..<m
        {
            for j in 0..<n
            {
                if grid[i][j] != 1
                {
                    continue
                }
                var cnt:Int = 0
                var q:[(Int,Int)] = [(i,j)]
                grid[i][j] *= -1
                while (!q.isEmpty)
                {
                    var t:(Int,Int) = q.first!
                    q.removeFirst()
                    cnt += 1
                    res = max(res, cnt)                    
                    for dir in dirs
                    {
                        var x:Int = t.0 + dir[0]
                        var y:Int = t.1 + dir[1]
                        if x < 0 || x >= m || y < 0 || y >= n || grid[x][y] <= 0
                        {
                            continue
                        }
                        grid[x][y] *= -1
                        q.append((x, y))
                    }
                }
            }
        }
        return res
    }
}