【LeetCode】 695. 島嶼的最大面積 dfs 2020年3月15日

題目

題目傳送門：傳送門（點擊此處）

題解

思路

最先想到這個題目和之前做過的一道題很像： 994. 腐爛的橘子

兩個題目都是 dfs的題目，使用 dfs 即可，關鍵就是代碼要如何來寫才漂亮，怎樣才能讓時間複雜度和空間複雜度最低

一開始我也繞彎兒了，現在想想，dfs 的代碼其實很簡單，完全不用那麼麻煩

1. 我的第一版代碼用了額外的數組標記是否訪問過，這個使用了 N的額外空間複雜度，其實可以避免，不過思路是沒有問題的，題目使用 dfs，每遇見 沒有訪問過的1 就進行一次 dfs，獲得每次的結果，再進行比較拿到最大的即可，最後的空間複雜度是 O(M*N)，時間複雜度是 O(M+N)

2. 第二版代碼有參考其他同學寫的，有了很大的改善，去掉了很多不必要的內容，把 dfs 改成了 遞歸 的形式，其實空間複雜度沒有改變，但是 不需要額外的數組來存儲，所以空間上會有一定的節省，最後的空間複雜度是 O(M*N)，時間複雜度是 O(M+N)

code

第一版

第一版有點慘不忍睹。。。。。。

class Solution {
    int rows;
    int cols;

    public int maxAreaOfIsland(int[][] grid) {
        rows = grid.length;
        cols = grid[0].length;

        int res = 0;
        int[][] visited = new int[rows][cols];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == 1 && visited[i][j] == 0) {
                    int sum = getSum(grid, visited, i, j);
                    res = sum > res ? sum : res;
                }
                visited[i][j] = 1;
            }
        }
        return res;
    }

    int getSum(int[][] grid, int[][] visited, int i, int j) {
        visited[i][j] = 1;
        int sum = 1;
        Queue<Point> queue = new LinkedList<>();
        queue.add(new Point(i, j));
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int k = 0; k < size; k++) {
                Point point = queue.poll();
                int x = point.x;
                int y = point.y;
                if (x > 0 && grid[x - 1][y] == 1 && visited[x - 1][y] == 0) {
                    sum++;
                    queue.add(new Point(x - 1, y));
                    visited[x - 1][y] = 1;
                }
                if (x < rows - 1 && grid[x + 1][y] == 1 && visited[x + 1][y] == 0) {
                    sum++;
                    queue.add(new Point(x + 1, y));
                    visited[x + 1][y] = 1;
                }
                if (y > 0 && grid[x][y - 1] == 1 && visited[x][y - 1] == 0) {
                    sum++;
                    queue.add(new Point(x, y - 1));
                    visited[x][y - 1] = 1;
                }
                if (y < cols - 1 && grid[x][y + 1] == 1 && visited[x][y + 1] == 0) {
                    sum++;
                    queue.add(new Point(x, y + 1));
                    visited[x][y + 1] = 1;
                }
            }

        }
        return sum;
    }

}

class Point {
    int x;
    int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

第二版

class Solution {
    
    int rows;
    int cols;

    public int maxAreaOfIsland(int[][] grid) {
        rows = grid.length;
        cols = grid[0].length;
        int res = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == 1) {
                    res = Math.max(res, dfs(i, j, grid));
                }
            }
        }
        return res;
    }

    int dfs(int i, int j, int[][] grid) {
        if (i < 0 || i >= rows || j < 0 || j >= cols || grid[i][j] == 0) {
            return 0;
        }
        int sum = 1;
        grid[i][j] = 0;
        sum += dfs(i - 1, j, grid);
        sum += dfs(i, j - 1, grid);
        sum += dfs(i + 1, j, grid);
        sum += dfs(i, j + 1, grid);
        return sum;
    }

}