第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(当前这一步的处理逻辑)
{
- 判断边界,是否已经一条道走到黑了:向上回退
- 尝试当下的每一种可能
- 确定一种可能之后,继续下一步 Dfs(下一步)
}
第2题 员工的重要性
给定一个保存员工信息的数据结构,它包含了员工唯一的id,重要度 和 直系下属的id。
现在输入一个公司的所有员工信息,以及单个员工id,返回这个员工和他所有下属的重要度之和。
1. 一个员工最多有一个直系领导,但是可以有多个直系下属
2. 员工数量不超过2000。
Dfs(当前这一步的处理逻辑)
{
- 获取id对应的重要度
- 累及其下属的重要度
- 确定一种可能之后,继续下一步 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,让你重新上色这幅图像。
- image 和 image[0] 的长度在范围 [1, 50] 内。
- 给出的初始点将满足 0 <= sr < image.length 和 0 <= sc < image[0].length。
- image[i][j] 和 newColor 表示的颜色值在范围 [0, 65535]内。
Dfs(当前这一步的处理逻辑)
{
- 修改颜色
- 搜索上下左右
{
判断新的位置是否符合要求(颜色,范围)
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;
}
};