图论-算法题 - 技术栈

797. 所有可能的路径

题目:

给你一个有 n 个节点的 有向无环图（DAG） ，请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）

graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。

示例 1：

输入：graph = [[1,2],[3],[3],[]]
输出：[[0,1,3],[0,2,3]]
解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3

示例 2：

输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]
输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]

答案

java 复制代码

class Solution {
    List<List<Integer>> res;
    List<Integer> list;
    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
        res = new ArrayList();
        list = new LinkedList();
        list.add(0);
        deal(graph,0);
        return res;
    }
    //回溯:深度优先遍历
    void deal(int[][] graph,int node){
        if(node==graph.length-1){
            res.add(new ArrayList(list));
        }
        for(int num : graph[node]){
            list.add(num);
            deal(graph,num);
            list.removeLast();
        }
    }
}

200. 岛屿数量

题目

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

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

示例 2：

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

答案

java 复制代码

class Solution {
    int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
    int m,n;
    public int numIslands(char[][] grid) {
        m = grid.length;
        n = grid[0].length;

        int res = 0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]=='1'){
                    res++;
                    deal(grid,i,j);//将遍历过的陆地--->水
                }
            }
        }
        return res;
    }
    void deal(char[][] grid,int i,int j){
        if(i<0 || i>=m || j<0 || j>=n || grid[i][j]=='0'){
            return;
        }
        grid[i][j] = '0';
        for(int[] dir : dirs){
            deal(grid,i+dir[0],j+dir[1]);
        }
    }
}

695. 岛屿的最大面积

题目

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例 1：

输入：grid = [[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：

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

答案

java 复制代码

class Solution {
    int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
    int m,n;
    int count;
    public int maxAreaOfIsland(int[][] grid) {
        m = grid.length;
        n = grid[0].length;

        int res = 0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1){
                    count = 0;
                    deal(grid,i,j);
                    res = Math.max(res,count);
                }
            }
        }
        return res;
    }
    void deal(int[][] grid,int i,int j){
        if(i<0 || i>=m || j<0 || j>=n || grid[i][j]==0){
            return;
        }
        grid[i][j] = 0;
        count++;
        for(int[] dir : dirs){
            deal(grid,i+dir[0],j+dir[1]);
        }
    }
}

1020. 飞地的数量

题目

给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。

一次移动是指从一个陆地单元格走到另一个相邻（上、下、左、右 ）的陆地单元格或跨过 grid 的边界。

返回网格中无法在任意次数的移动中离开网格边界的陆地单元格的数量。

示例 1：

输入：grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
输出：3
解释：有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。

示例 2：

输入：grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
输出：0
解释：所有 1 都在边界上或可以到达边界。

答案

java 复制代码

class Solution {
    int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
    int m,n;

    public int numEnclaves(int[][] grid) {
        m = grid.length;
        n = grid[0].length;
        for(int i=0;i<m;i++){
            deal(grid,i,0);
            deal(grid,i,n-1);
        }
        for(int j=0;j<n;j++){
            deal(grid,0,j);
            deal(grid,m-1,j);
        }
        int res = 0;
        for(int i=1;i<m-1;i++){
            for(int j=1;j<n-1;j++){
                if(grid[i][j]==1){
                    res++;
                }
            }
        }
        return res;
    }
    void deal(int[][] grid,int i,int j){
        if(i<0 || i>=m || j<0 || j>=n || grid[i][j]==0){
            return;
        }
        grid[i][j] = 0;
        for(int[] dir : dirs){
            deal(grid,i+dir[0],j+dir[1]);
        }
    }
}

130. 被围绕的区域

题目

给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

示例 1：

输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
输出：[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是"相连"的。

示例 2：

输入：board = [["X"]]
输出：[["X"]]

答案

java 复制代码

class Solution {
    int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
    int m,n;

    public void solve(char[][] board) {
        m = board.length;
        n = board[0].length;

        for(int i=0;i<m;i++){
            deal(board,i,0);
            deal(board,i,n-1);
        }
        for(int j=0;j<n;j++){
            deal(board,0,j);
            deal(board,m-1,j);
        }
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(board[i][j]=='A'){
                    board[i][j] = 'O';
                }else if(board[i][j]=='O'){
                    board[i][j] ='X';
                }
            }
        }
    }
    void deal(char[][] board,int i,int j){
        if(i<0 || i>=m || j<0 || j>=n || board[i][j]!='O'){
            return;
        }
        board[i][j] = 'A';
        for(int[] dir : dirs){
            deal(board,i+dir[0],j+dir[1]);
        }
    }
}

841. 钥匙和房间

题目

有 n 个房间，房间按从 0 到 n - 1 编号。最初，除 0 号房间外的其余所有房间都被锁住。你的目标是进入所有的房间。然而，你不能在没有获得钥匙的时候进入锁住的房间。

当你进入一个房间，你可能会在里面找到一套不同的钥匙，每把钥匙上都有对应的房间号，即表示钥匙可以打开的房间。你可以拿上所有钥匙去解锁其他房间。

给你一个数组 rooms 其中 rooms[i] 是你进入 i 号房间可以获得的钥匙集合。如果能进入所有房间返回 true，否则返回 false。

示例 1：

输入：rooms = [[1],[2],[3],[]]
输出：true
解释：
我们从 0 号房间开始，拿到钥匙 1。
之后我们去 1 号房间，拿到钥匙 2。
然后我们去 2 号房间，拿到钥匙 3。
最后我们去了 3 号房间。
由于我们能够进入每个房间，我们返回 true。

示例 2：

输入：rooms = [[1,3],[3,0,1],[2],[0]]
输出：false
解释：我们不能进入 2 号房间。

答案

java 复制代码

class Solution {
    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        boolean[] visited = new boolean[rooms.size()];
        Queue<Integer> queue = new LinkedList();

        queue.offer(0);
        visited[0] = true;//注意这个
        while(!queue.isEmpty()){
            int curr = queue.poll();
            for(int index : rooms.get(curr)){
                if(!visited[index]){
                    visited[index] = true;
                    queue.offer(index);
                }
            }
        }

        for(boolean flag : visited){
            if(!flag){
                return false;
            }
        }
        return true;
    }
}

463. 岛屿的周长

题目

给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。

网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。

岛屿中没有"湖"（"湖" 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。

示例 1：

输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
输出：16
解释：它的周长是上面图片中的 16 个黄色的边

示例 2：

输入：grid = [[1]]
输出：4

示例 3：

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

答案

java 复制代码

class Solution {
    int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
    int m,n;
    public int islandPerimeter(int[][] grid) {
        m = grid.length;
        n = grid[0].length;

        int res = 0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1){
                    for(int[] dir : dirs){
                        int p = i + dir[0];
                        int q = j + dir[1];
                        if(p<0 || p>=m || q<0 || q>=n || grid[p][q]==0){
                            res++;
                        }
                    }
                }
            }
        }
        return res;
    }
}