swift LeetCode岛屿类问题

最新推荐文章于 2024-10-08 12:54:42 发布

langyuejing

最新推荐文章于 2024-10-08 12:54:42 发布

阅读量99

点赞数

分类专栏： IOS swift LeetCode 文章标签：算法 swift dfs leetcode

本文链接：https://blog.csdn.net/chocolateloveme/article/details/114993562

版权

IOS 同时被 3 个专栏收录

125 篇文章 0 订阅

订阅专栏

swift

4 篇文章 0 订阅

订阅专栏

LeetCode

1 篇文章 0 订阅

订阅专栏

swift LeetCode岛屿类问题
200. 岛屿数量

class Solution {
    func numIslands(_ grid: [[Character]]) -> Int {
        guard grid.count > 0 && grid[0].count > 0 else {
           return -1
        }
        var res = grid
        var count = 0
        for i in 0..<res.count {
            for j in 0..<res[0].count {
                if res[i][j] == "1" {
                    dfs(&res, i, j)
                    count = count + 1
                }
            }
        }
        return count
    }

    func dfs(_ grid: inout [[Character]],_ r:Int,_ c:Int) -> Void {
        if !inArea(grid, r, c) {
            return
        }
        if (grid[r][c] != "1") {
            return;// 如果这个格子不是岛屿，直接返回
        }
        grid[r][c] = "2"; // 将格子标记为「已遍历过」
        // 访问上、下、左、右四个相邻结点
        dfs(&grid, r - 1, c);
        dfs(&grid, r + 1, c);
        dfs(&grid, r, c - 1);
        dfs(&grid, r, c + 1);
    }
    // 判断坐标 (r, c) 是否在网格中
    func inArea(_ grid: [[Character]],_ r:Int,_ c:Int) -> Bool {
        return 0 <= r && r < grid.count
        && 0 <= c && c < grid[0].count;
    }
}

岛屿的周长

class Solution {
    func islandPerimeter(_ grid: [[Int]]) -> Int {
        guard grid.count > 0 && grid[0].count > 0 else {
           return -1
        }
        var res = grid
        var count = 0
        for i in 0..<res.count  {
            for j in 0..<res[0].count {
                if res[i][j] == 1 {
                   return dfs(&res, i, j)
                }
            }
        }
        return count
    }

    func dfs(_ grid: inout [[Int]],_ r:Int,_ c:Int) -> Int {
        if !inArea(grid, r, c) {
            return 1
        }
        if (grid[r][c] == 0) {
            return 1;
        }
        if (grid[r][c] != 1) {
            return 0;
        }
        grid[r][c] = 2; // 将格子标记为「已遍历过」
        // 访问上、下、左、右四个相邻结点
        return dfs(&grid, r - 1, c)+dfs(&grid, r + 1, c)+dfs(&grid, r, c - 1)+dfs(&grid, r, c + 1)
    }

    // 判断坐标 (r, c) 是否在网格中
    func inArea(_ grid: [[Int]],_ r:Int,_ c:Int) -> Bool {
        return r >= 0 && r < grid.count
        && c >= 0 && c < grid[0].count;
    }
}

岛屿的最大面积

class Solution {
    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
        guard grid.count > 0 || grid[0].count > 0 else {
            return 0
        }
        var num = 0
        var res = grid
        for i in 0..<res.count {
            for j in 0..<res[0].count {
                if res[i][j] == 1 {
                   let a = dfs(&res,i,j)
                   num = max(a,num)   
                }
            }
        }
        return num
    }
    
    func dfs(_ grid: inout [[Int]],_ i:Int,_ j:Int) -> Int {
        if(!inArea(grid,i,j)) {
           return 0 
        }
        if grid[i][j] != 1 {
           return 0
        }
        grid[i][j] = 2
        return 1+dfs(&grid,i-1,j)+dfs(&grid,i,j-1)+dfs(&grid,i+1,j)+dfs(&grid,i,j+1)
    }

    func inArea(_ grid: [[Int]],_ i:Int,_ j:Int) -> Bool {
         return i>=0&&i<grid.count&&j>=0&&j<grid[0].count
    }
}