【LeetCode】Sama的个人记录_31

 

【Q310】(md) 被围绕的区域
 
给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。
 
找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。
 
示例:

  	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

class Solution {
    /**
     *【DFS】
     *
     * 或许判断哪些O被X完全包围有些困难，但我们可以轻易知道哪些O是未被包围的————与边界O相连通的!!!
     *
     * 思路为：
     * 从边界开始DFS，标记所有的O为A
     * 遍历整个board矩阵，所有标记A被修正为O(为被X完全包围)，所有O变成X(被X包围了)
     *
     * 总之，这是一个【补集】的思想
     */
    public void solve(char[][] board) {
        if(board == null || board.length == 0){
            return;
        }

        for(int i = 0; i < board.length; i++){
            DFS(board, i, 0);
            DFS(board, i, board[0].length - 1);
        }
        for(int j = 0; j < board[0].length; j++){
            DFS(board, 0, j);
            DFS(board, board.length - 1, j);
        }

        for(int i = 0; i < board.length; i++){
            for(int j = 0; j < board[0].length; j++){
                if(board[i][j] == 'A'){
                    board[i][j] = 'O';
                }else if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }
            }
        }

    }

    private void DFS(char[][] board, int x, int y){
        if(x < 0 || x >= board.length || y < 0 || y >= board[0].length || board[x][y] != 'O'){
            return;
        }
        board[x][y] = 'A';
        DFS(board, x + 1, y);
        DFS(board, x - 1, y);
        DFS(board, x, y + 1);
        DFS(board, x, y - 1);
    }
}

 
 
 

【Q133】(md) 克隆图
 
给你 无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。
 
给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。

提示：

1. 节点数不超过 100 。
2. 每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。
3. 无向图是一个简单图，这意味着图中没有重复的边，也没有自环。
4. 由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p的邻居。
5. 图是连通图，你可以从给定节点访问到所有节点。

// 题目已知
class Node {
    public int val;
    public List<Node> neighbors;
    
    public Node() {
        val = 0;
        neighbors = new ArrayList<Node>();
    }
    
    public Node(int _val) {
        val = _val;
        neighbors = new ArrayList<Node>();
    }
    
    public Node(int _val, ArrayList<Node> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
}

 

class Solution {
    /**
     * 【DFS】
     * 本题的关键点有两个：
     *          1.map存放由被克隆节点向隆节点的映射，这类似于memo数组，但目的不是优化而是防止递归死循环
     *          2.因为深拷贝，指向邻居节点的引用先设置为空，在往里添加克隆后的节点(千万不要直接指向被克隆图的节点)
     * 解释：
     *          1.A引用到B，B同样引用到A(无向图)，A在递归到B之前，先存放在map中，下次B再递归到A时，直接取出，避免了AB死循环
     *          2.无论是DFS还是BFS，邻居节点一定也是我们克隆出的节点!
     */
    private Map<Node, Node> map = new HashMap<>();
    public Node cloneGraph(Node node) {
        if(node == null){
            return null;
        }
        // 防止死循环的关键(保证每个节点只有一个，而不是来回返回克隆)
        if(map.containsKey(node)){
            return map.get(node);
        }

        // 克隆本节点(注意两点：邻居节点先设置为空，之后再往里加克隆出的节点；立即加入哈希表中)
        Node cloneNode = new Node(node.val, new ArrayList<>());
        map.put(node, cloneNode);

        for(Node neighbor : node.neighbors){
            cloneNode.neighbors.add(cloneGraph(neighbor));
        }
        return cloneNode;
    }
}

class Solution {
    /**
     *【BFS】
     * 首先有两个关键点(关于"哈希表"和"深拷贝")在上面已经提到过
     *
     * BFS的思路肯定是和DFS不相同的：
     * 队列中是被克隆节点，每次map新加入一个映射时，就将该被克隆节点加入队列中
     * 每次出队，就将其邻居节点克隆完成(val在入队之前就克隆完了)
     */
    public Node cloneGraph(Node node) {
        if(node == null){
            return null;
        }

        Map<Node, Node> map = new HashMap<>();
        LinkedList<Node> queue = new LinkedList<>();
        map.put(node, new Node(node.val, new ArrayList<>()));
        queue.add(node);

        while(!queue.isEmpty()){
            Node cur = queue.remove();
            for(Node neighbor : cur.neighbors){
                if(!map.containsKey(neighbor)){
                    map.put(neighbor, new Node(neighbor.val, new ArrayList<>()));
                    queue.add(neighbor);
                }
                map.get(cur).neighbors.add(map.get(neighbor));
            }
        }

        return map.get(node);
    }
}

 
 

 

 

 

 

 

 

 

 

 
 

 

 

Qs from https://leetcode-cn.com
♥ loli suki
♠ end