深度优先搜索(BFS)

第1题 放置扑克牌

假如有编号为1~ 3的3张扑克牌和编号为1~3的3个盒子，现在需要将3张牌分别放到3个盒子中去，且每个盒子只能放一张牌，一共有多少种不同的放法。

• 当走到一个盒子面前的时候，到底要放那一张牌呢？在这里应该把所有的牌都尝试一遍。假设这里约定一个顺序，按牌面值从小到大依次尝试。在这样的假定下，当走到第一个盒子的时候，放入1号牌。
• 放好之后，继续向后走，走到第二个盒子面前，此时还剩2张牌，牌面值最小的为2号牌，按照约定的规则，把2号牌放入第二个盒子。
• 此时，来到第三个盒子面前，只剩一张牌，放入第三个盒子。此时手中的牌已经用完。
• 继续向后走，走到了盒子的尽头，后面再也没有盒子，并且也没有可用的牌了，此时，一种放法已经完成了，但是这只是一种放法，这条路已经走到了尽头，还需要折返，重新回到上一个盒子。
• 这里回到第三个盒子，把第三个盒子中的牌取出来，再去尝试能否再放其它的牌，这时候手里仍然只有一张3号牌，没有别的选择了，所以还需要继续向后回退，回到2号盒子面前。
• 收回2号盒子中的2号牌，现在手里有两张牌，2，3，按照约定，再把3号牌放入2号盒子，放好之后，继续向后走，来到3号盒子。
• 此事手里只有一张2号牌，把它放入3号盒子，继续向后走。
• 此时这条路又一次走到了尽头，一个新的放法又产生了，继续向上折返，尝试其它可能，按照上述步骤，依次会产生所有结果。

代码如何实现这种过程呢？最主要的事情，向面前的盒子里放每一种牌，一个for循环搞定。这里还需考虑，现在手里有没有这张牌，用一个数组book标记手里是否有这张牌
面前的盒子处理完成之后，继续处理下一个盒子，下一个盒子的处理方法和当前一样。那么把上面的代码块封装一下，给它取一个名字，即为Dfs(Depth First Search)。
现在再去处理下一个盒子，直接调用Dfs(index + 1, boxs, book)即可。
现在考虑什么时候得到一种方法呢，走到尽头，也就是第n+1个盒子的时候，表明前面的盒子已经放好牌了，这时候直接打印每个盒子中的牌即可。已走到尽头，向上回退。

#include <vector>
#include <iostream>
using namespace std;
void Dfs(int index, int n, vector<int>& boxs, vector<int>& book)
{
    if (index == n + 1)
    {
        for (int i = 1; i <= n; i++)
            cout << boxs[i] << " ";
        cout << endl;
        return; //向上回退
    }
    for (int i = 1; i <= n; i++)
    {
        if (book[i] == 0)  //第i号牌仍在手上
        {
            boxs[index] = i;
            book[i] = 1;  //现在第i号牌已经被用了
            //处理下一个盒子
            Dfs(index + 1, n, boxs, book);
            //从下一个盒子回退到当前盒子，取出当前盒子的牌，
            //尝试放入其它牌。
            book[i] = 0;
        }
    }
}
int main()
{
    int n;
    cin >> n;
    vector<int> boxs(n + 1, 0);
    vector<int> books(n + 1, 0);
    Dfs(1, n, boxs, books);
    return 0;
}

从上面的代码可以看出，深度优先搜索的关键是解决"当下该如何做"，下一步的做法和当下的做法是一样的。"当下如何做"一般是尝试每一种可能，用for循环遍历，对于每一种可能确定之后，继续走下一步，当前的剩余可能等到从下一步回退之后再处理。我们可以抽象出深度优先搜索的模型。

Dfs(当前这一步的处理逻辑)
{

1. 判断边界，是否已经一条道走到黑了：向上回退
2. 尝试当下的每一种可能
3. 确定一种可能之后，继续下一步 Dfs(下一步)

}

---

第2题 员工的重要性

给定一个保存员工信息的数据结构，它包含了员工唯一的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:

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

注意:

1. 一个员工最多有一个直系领导，但是可以有多个直系下属
2. 员工数量不超过2000。

Dfs(当前这一步的处理逻辑)
{

1. 获取id对应的重要度
2. 累及其下属的重要度
3. 确定一种可能之后，继续下一步 Dfs(下一步)

}

/*
// Employee info
class Employee {
public:
    // It's the unique ID of each node.
    // unique id of this employee
    int id;
    // the importance value of this employee
    int importance;
    // the id of direct subordinates
    vector<int> subordinates;
};
*/
class Solution {
public:
    int DFS(int id,unordered_map<int,Employee*>& info)
    {
    	//通过哈希表查询id对应的员工，获取员工的importance属性
        int ret=info[id]->importance;
        //累加下属的importance属性
        for(int i=0;i<info[id]->subordinates.size();i++)
        {
            ret+=DFS(info[id]->subordinates[i],info);
        }
        //返回累加和
        return ret;
    }
    int getImportance(vector<Employee*> employees, int id) 
    {
        if(employees.empty())
            return 0;
        unordered_map<int,Employee*> info;
        for(auto& e:employees)
        {
            info[e->id]=e;
        }
        return DFS(id,info);
    }
};

---

第3题 图像渲染

有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。

给你一个坐标 (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，
因为它不是在上下左右四个方向上与初始点相连的像素点。

注意:

• image 和 image[0] 的长度在范围 [1, 50] 内。
• 给出的初始点将满足 0 <= sr < image.length 和 0 <= sc < image[0].length。
• image[i][j] 和 newColor 表示的颜色值在范围 [0, 65535]内。

Dfs(当前这一步的处理逻辑)
{

1. 修改颜色
2. 搜索上下左右
   {
   判断新的位置是否符合要求（颜色，范围）
   DFS（新的位置）
   }

}

int pos[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
class Solution {
    public:
    void dfs(vector<vector<int>>& image, int row, int col, vector<vector<int>>& book,
             int x, int y, int oldColor, int newColor)
    {
        //处理当前逻辑，修改颜色，并且标记已经修改过了
        image[x][y] = newColor;
        book[x][y] = 1;
        //遍历每一种可能，四个方向
        for (int i = 0; i < 4; ++i)
        {
            int nx = x + pos[i][0];
            int ny = y + pos[i][1];
            //判断新位置是否越界
            if (nx >= row || nx < 0|| ny >= col || ny < 0)
                continue;
            //如果颜色符合要求，并且之前也没有渲染过，则继续渲染
            if (image[nx][ny] == oldColor && book[nx][ny] == 0)
            {
                dfs(image, row, col, book, nx, ny, oldColor, newColor);
            }
        }
    }
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) 
    {
        if (image.empty())
            return image;
        int row = image.size();
        int col = image[0].size();
        //建立标记
        vector<vector<int>> book(row,vector<int>(col,0));
        //获取旧的颜色
        int oldColor = image[sr][sc];
        dfs(image, row, col, book, sr, sc, oldColor, newColor);
        return image;
    }
};

---