leetcode--回溯算法

690. 员工的重要性
     给定一个保存员工信息的数据结构，它包含了员工 唯一的 id ，重要度 和 直系下属的 id 。

比如，员工 1 是员工 2 的领导，员工 2 是员工 3 的领导。他们相应的重要度为 15 , 10 , 5 。那么员工 1 的数据结构是 [1, 15, [2]] ，员工 2的 数据结构是 [2, 10, [3]] ，员工 3 的数据结构是 [3, 5, []] 。注意虽然员工 3 也是员工 1 的一个下属，但是由于 并不是直系 下属，因此没有体现在员工 1 的数据结构中。

现在输入一个公司的所有员工信息，以及单个员工 id ，返回这个员工和他所有下属的重要度之和。

示例：

输入：[[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1
输出：11
解释：
员工 1 自身的重要度是 5 ，他有两个直系下属 2 和 3 ，而且 2 和 3 的重要度均为 3 。因此员工 1 的总重要度是 5 + 3 + 3 = 11 。

/*
// Definition for Employee.
class Employee {
    public int id;
    public int importance;
    public List<Integer> subordinates;
};
*/

class Solution {

    public int DFS(Map<Integer, Employee> info, int id) {
        // 累加当前员工和直接下属的值
        int curImportance = info.get(id).importance;
        for(int subId: info.get(id).subordinates) {
            curImportance += DFS(info, subId); 
        }
        return curImportance;
    }

    public int getImportance(List<Employee> employees, int id) {

/深度优先搜索
        // Map<Integer, Employee>info = new HashMap<>();
        // for (Employee cur : employees) {
        //     info.put(cur.id, cur);
        // }
        // return DFS(info, id);


/广度优先搜索
        Map<Integer, Employee>info = new HashMap<>();
        for (Employee cur : employees) {
            info.put(cur.id, cur);
        }

        // 起始id 入队
        Queue<Integer> queue = new LinkedList<Integer>();
        queue.offer(id);

        int sum = 0;
        while (!queue.isEmpty()) {
            int curId = queue.peek();
            queue.poll();
            sum += info.get(curId).importance;
            // 下属入列
            for (int subId :
                    info.get(curId).subordinates) {
                queue.offer(subId);
            }
        }
        return sum;
    }
}

733. 图像渲染
     有一幅以 m x n 的二维整数数组表示的图画 image ，其中 image[i][j] 表示该图画的像素值大小。

你也被给予三个整数 sr , sc 和 newColor 。你应该从像素 image[sr][sc] 开始对图像进行 上色填充 。

为了完成 上色工作 ，从初始像素开始，记录初始坐标的 上下左右四个方向上 像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上 像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为 newColor 。

最后返回 经过上色渲染后的图像 。

示例 1:

输入: image = [[1,1,1],[1,1,0],[1,0,1]]，sr = 1, sc = 1, newColor = 2
输出: [[2,2,2],[2,2,0],[2,0,1]]
解析: 在图像的正中间，(坐标(sr,sc)=(1,1)),在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，因为它不是在上下左右四个方向上与初始点相连的像素点。

class Solution {
    public void DFS(int[][] image, int row, int col, int[][] visited, int newX, int newY, int oldColor, int newColor) {
        int[][] nextP = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        // 1.染色
        image[newX][newY] = newColor;
        visited[newX][newY] = 1;
        // 2.搜索新的位置：上下左右
        // 上
        for (int i = 0; i < 4; i++) {
            int nextX = newX + nextP[i][0];
            int nextY = newY + nextP[i][1];

            // 3.判断位置有效性
            if (nextX < 0 || nextX >= row || nextY < 0 || nextY >= col) {
                continue;
            }
            // 颜色如果符合要求，且没被搜索过
            if (image[nextX][nextY] == oldColor && visited[nextX][nextY] == 0){
                DFS(image, row, col, visited, nextX, nextY, oldColor, newColor);
            }
        }

    }

    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        int row = image.length;
        int col = image[0].length;
        int[][] visited = new int[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                visited[i][j] = 0;
            }
        }
        int oldColor = image[sr][sc];
        DFS(image, row, col, visited, sr, sc, oldColor, newColor);
        return image;
    }
}

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’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

class Solution {
    int[][] nextP = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    void DFS(char[][] board, int row, int col, int x, int y){
        // 1. 标记
        board[x][y] = 'a';
        // 2. 搜索
        for (int i = 0; i < 4; i++) {
            int nx = x + nextP[i][0];
            int ny = y + nextP[i][1];
            // 3. 判断
            if (nx <= 0 || nx >= row || ny <= 0 || ny >= col) {
                continue;
            }
            if (board[nx][ny] == 'O'){
                DFS(board, row, col, nx, ny);
            }
        }
    }
    public void solve(char[][] board) {
        int row = board.length;
        if (row == 0)
            return;
        int col = board[0].length;
        // 搜索所有边上所有的o 
        // 以每一个边上的o为起点，找到和边上联通的所有的o
        for (int i = 0; i < col; i++) {
            // 第一行
            if (board[0][i] == 'O')
                DFS(board ,row, col, 0, i);
            // 最后一行
            if (board[row - 1][i] == 'O')
                DFS(board ,row, col, row - 1, i);            
        }
        for (int i = 0; i < row - 1; i++) {
            // 第一列
            if (board[i][0] == 'O')
                DFS(board ,row, col, i, 0);
            // 最后一列
            if (board[i][col - 1] == 'O')
                DFS(board ,row, col, i, col - 1);
        }
        
        // 替换，恢复
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (board[i][j] == 'O'){
                    board[i][j] = 'X';
                }
                else if (board[i][j] == 'a'){
                    board[i][j] = 'O';
                }
            }
        }
    }
}