Leetcode刷题笔记—dfs（10）不熟悉

310. Minimum Height Trees

class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> list = new ArrayList();
        if(edges.length == 0) {
            list.add(0);
            return list;
        }
        int[] indegree = new int[n];
        HashMap<Integer, ArrayList<Integer>> map = new HashMap();
        for(int i = 0; i < n; i++) {
            map.put(i, new ArrayList());
        }
        for(int i = 0; i < edges.length; i++) {
            //无向图有两个入度
            indegree[edges[i][0]]++;
            indegree[edges[i][1]]++;
            map.get(edges[i][0]).add(edges[i][1]);
            map.get(edges[i][1]).add(edges[i][0]);
        }

        Queue<Integer> q = new LinkedList();
        for(int i = 0; i < n; i++) {
            if(indegree[i] == 1) {
                q.offer(i);
            }
        }
        int count = 0;
        while(! q.isEmpty()) {
            int size = q.size();
            count += size;
            for(int i = 0; i < size; i++) {
                int id = q.poll();
                indegree[id]--;
                if(count == n) {
                    list.add(id);
                }
                for(int adjacentId : map.get(id)){
                    if(indegree[adjacentId] != 0) {
                        indegree[adjacentId]--;
                        if(indegree[adjacentId] == 1) {
                            q.offer(adjacentId);
                        }
                    }
                }
            }
        }
        return list;
    }
}

98. Validate Binary Search Tree

class Solution {
    public boolean isValidBST(TreeNode root) {
        if(root == null) {
            return true;
        }
        Stack<TreeNode> stack = new Stack();
        TreeNode pre = null;
        while(root != null || !stack.isEmpty()) {
            while(root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            while(pre != null && root.val <= pre.val) return false;
            pre = root;
            root = root.right;
        }
        return true;
    }
}

463. Island Perimeter

class Solution {
    public int islandPerimeter(int[][] grid) {
       if(grid.length == 0 || grid[0].length == 0) {
           return 0;
       } 
       int land = 0;
       int overlap = 0;
       for(int i = 0; i < grid.length; i++) {
           for(int j = 0; j < grid[i].length; j++) {
               if(grid[i][j] == 1) {
                   land++;
                   if(i < grid.length - 1 && grid[i][j] == grid[i + 1][j]) {
                       overlap++;
                   }
                   if(j < grid[i].length - 1 && grid[i][j] == grid[i][j + 1])
                   overlap++;
               }
           }
       }
       return land * 4 - overlap * 2;
    }
}

1905. Count Sub Islands

class Solution {
    public int countSubIslands(int[][] grid1, int[][] grid2) {
        int m = grid2.length, n = grid2[0].length;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(grid1[i][j] == 0 && grid2[i][j] == 1) {
                    dfs(grid2, i, j, m, n);
                }
            }
        }
        int count = 0;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(grid2[i][j] == 1) {
                    count++;
                    dfs(grid2, i, j, m, n);
                }
            }
        }
        return count;
    }
    public void dfs(int[][] grid2, int i, int j, int m, int n) {
        if(i < 0 || i >= m || j < 0 || j >= n) {
            return;
        }
        if(grid2[i][j] == 0) {
            return;
        }
        grid2[i][j] = 0;
        dfs(grid2, i - 1, j, m, n);
        dfs(grid2, i + 1, j, m, n);
        dfs(grid2, i, j + 1, m, n);
        dfs(grid2, i, j - 1, m, n);
    }
}

1254. Number of Closed Islands 

class Solution {
    public int closedIsland(int[][] grid) {
       int m = grid.length, n = grid[0].length;
       int count = 0;
        for(int i = 0; i < m; i++) {
           dfs(grid, i, 0, m, n);
            dfs(grid, i, n - 1, m, n);
        }
        for(int j = 0; j < n; j++) {
           dfs(grid, 0, j, m, n);
           dfs(grid, m - 1, j, m, n);
        }
       for(int i = 0; i < m; i++) {
           for(int j = 0; j < n; j++) {
               if(grid[i][j] == 0) {
                   count++;
                   dfs(grid, i, j, m, n);
               }
           }
       }
       return count;
    }
    public void dfs(int[][] grid, int i, int j, int m, int n) {
        if(i < 0 || i >= m || j < 0 || j >= n) {
            return;
        }
        if(grid[i][j] == 1) {
            return;
        }
        grid[i][j] = 1;
        dfs(grid, i + 1, j, m, n);
        dfs(grid, i - 1, j, m, n);
        dfs(grid, i, j + 1, m, n);
        dfs(grid, i, j - 1, m, n);
    }
}

695. Max Area of Island

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
       int m = grid.length, n = grid[0].length;
       int max = 0;
       for(int i = 0; i < m; i++) {
           for(int j = 0; j < n; j++) {
               if(grid[i][j] == 1) {
                   int curArea = dfs(grid, i, j, m, n);
                   max = Math.max(max, curArea);
               }
           }
       } 
       return max;
    }
    public int dfs(int[][] grid, int i, int j, int m, int n) {
        if(i < 0 || i >= m || j < 0 || j >= n) {
            return 0;
        }
        if(grid[i][j] == 0) {
            return 0;
        }
        grid[i][j] = 0;
        return 1 + dfs(grid, i + 1, j, m, n) + dfs(grid, i - 1, j, m, n) + dfs(grid, i, j + 1, m, n) + dfs(grid, i, j - 1, m, n);
    }
}

200. Number of Islands  

class Solution {
    public int numIslands(char[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int count = 0;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(grid[i][j] == '1') {
                    count++;
                    dfs(grid, i, j, m, n);
                }
            }
        }
        return count;
    }
    public void dfs(char[][] grid, int i, int j, int m, int n) {
        if(i < 0 || i >= m || j < 0 || j >= n) {
            return;
        }
        if(grid[i][j] == '0') {
            return;
        }
        grid[i][j] = '0';
        dfs(grid, i + 1, j, m, n);
        dfs(grid, i - 1, j, m, n);
        dfs(grid, i, j + 1, m, n);
        dfs(grid, i, j - 1, m, n);
    }
}

733. Flood Fill 

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int color) {
        if(image[sr][sc] == color) return image;
        fill(image, sr, sc, color, image[sr][sc]);
        return image;
    }
    public void fill(int[][] image, int sr, int sc, int color, int cur) {
        if(sr < 0 || sr >= image.length || sc < 0 || sc >= image[0].length) {
            return;
        }
        if(cur != image[sr][sc]) return;
        image[sr][sc] = color;
        fill(image, sr - 1, sc, color, cur);
        fill(image, sr + 1, sc, color, cur);
        fill(image, sr, sc - 1, color, cur);
        fill(image, sr, sc + 1, color, cur);
    }
}

1971. Find if Path Exists in Graph 待通过

class Solution {
    public boolean validPath(int n, int[][] edges, int source, int destination) {
        ArrayList<Integer>[] graph = new ArrayList[n];
        for(int i = 0; i < n; i++) {
            graph[i] = new ArrayList();
        }
        for(int[] edge : edges) {
            graph[edge[0].add(edge[1])];
            graph[edge[1].add(edge[0])];
        }
        boolean[] visited = new boolean[n];
        return hasPath(graph, visited, source, destination);
    }
    public boolean hasPath(ArrayList<Integer>[] graph, boolean[] visited, int src, int dest) {
        if(src = dest) {
            return true;
        }
        visited[src] = true;
        for(int nbr : graph[src]) {
            if(visited[nbr] == false) {
                boolean pathExists = hasPath(graph, visited, nbr, dest);
            }
            if(pathExists) {
                return true;
            }
        }
    }
    return false;
}

2331. Evaluate Boolean Binary Tree 

class Solution {
    public boolean evaluateTree(TreeNode root) {
       if(root.val == 0) return false;
       if(root.val == 1) return true;
       if(root.val == 2) return evaluateTree(root.left) || evaluateTree(root.right);
       return evaluateTree(root.left) && evaluateTree(root.right);
    }
}