所可能的路径
给定一个graph，题目要求从结点0到n - 1的结点的所有路径。这个n指的是graph的行下标。
拿一组测试用例来说明吧。不然不好理解题意
graph = [[1,2],[3],[3],[]]
题目大致就是这么个意思。题目保证了输入为有向无环图。那么就可以确定，一定会有结点0到n的路径。
class Solution {
vector<vector<int>> res;//保存答案
vector<int> path;//保存每一条路径
void dfs(vector<vector<int>>& graph, int x){
if(x == graph.size() - 1){//结束条件是：遍历到的结点等于n
res.push_back(path);//将路径添加到答案中
return;
}
for(int i = 0; i < graph[x].size(); i++){//遍历每一行
path.push_back(graph[x][i]);//插入遍历到的结点
dfs(graph, graph[x][i]);//再dfs插入的结点。
path.pop_back();
}
}
public:
vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
path.push_back(0);//确定了每一条路径都是从结点0开始，所以直接插入0
dfs(graph, 0);//从0这一开始dfs。
return res;
}
};
这很辛苦，但我觉得对于初学者来说，很有必要。一步一步分析递归和回溯，这样才能更好的理解dfs。多分析个几次，就回慢慢变快了。
岛屿数量
给定一个grid二维数组，数组中的‘1’，表示 陆地，‘0’表示海水。该题要求岛屿的数量，可以使用dfs,也可以使用bfs。遍历到陆地，就把它标记已经遍历过，假如到海水，岛屿数量加1。
dfs
class Solution {
int n, m;
void dfs(vector<vector<int>>& visit,vector<vector<char>>& grid, int i, int j){
//上下左右遍历。
if(i - 1 >= 0 && grid[i - 1][j] == '1' && visit[i - 1][j] == 0) {
visit[i - 1][j] = 1;
dfs(visit, grid, i - 1, j);
}
if(i + 1 < n && grid[i + 1][j] == '1' && visit[i + 1][j] == 0) {
visit[i + 1][j] = 1;
dfs(visit,grid, i + 1, j);
}
if(j - 1 >= 0 && grid[i][j - 1] == '1' && visit[i][j - 1] == 0) {
visit[i][j - 1] = 1;
dfs(visit, grid, i, j - 1);
}
if(j + 1 < m && grid[i][j + 1] == '1' && visit[i][j + 1] == 0) {
visit[i][j + 1] = 1;
dfs(visit,grid, i, j + 1);
}
}
public:
int numIslands(vector<vector<char>>& grid) {
n = grid.size();
m = grid[0].size();
int res = 0;
vector<vector<int>> visit = vector<vector<int>>(n, vector<int>(m, 0));
//0代表没有被标记.用一个数组去标记是否已经遍历过。
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(visit[i][j] == 0 && grid[i][j] == '1'){
//假如这个位置没有被遍历过，且这个位置是陆地
res++;
visit[i][j] = 1;
dfs(visit, grid, i, j);
}
}
}
return res;
}
};上一个是使用一个数组来标记这个位置是否被遍历过。也可以不使用数组来标记
class Solution {
int n, m;
public:
int numIslands(vector<vector<char>>& grid) {
int res = 0;
n = grid.size();
m = grid[0].size();
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(grid[i][j] == '1'){
res++;
dfs(grid, i, j);
}
}
}
return res;
}
void dfs(vector<vector<char>>& grid, int i, int j){
grid[i][j] = '0'; // 一旦遍历过，直接把它标记为0.
if(i - 1 >= 0 && grid[i - 1][j] == '1') dfs(grid, i - 1, j);
if(i + 1 < n && grid[i + 1][j] == '1') dfs(grid, i + 1, j);
if(j - 1 >= 0 && grid[i][j - 1] == '1') dfs(grid, i, j - 1);
if(j + 1 < m && grid[i][j + 1] == '1') dfs(grid, i, j + 1);
}
};下面介绍bfs, bfs是利用一个队列，去记录遍历的位置。
class Solution {
int n,m;
public:
void bfs(vector<vector<char>>& grid, int i,int j){
queue<pair<int,int>> qu;
qu.push({i,j});
while(!qu.empty()){
pair<int, int> cur = qu.front();
qu.pop();
int curi = cur.first;
int curj = cur.second;
if(curi - 1 >= 0 && grid[curi - 1][curj] == '1'){
grid[curi - 1][curj] = '0';
qu.push({curi - 1, curj});
}
if(curi + 1 < n && grid[curi + 1][curj] == '1'){
grid[curi + 1][curj] = '0';
qu.push({curi + 1, curj});
}
if(curj - 1 >= 0 && grid[curi ][curj - 1] == '1'){
grid[curi ][curj - 1] = '0';
qu.push({curi , curj - 1});
}
if(curj + 1 < m && grid[curi ][curj + 1] == '1'){
grid[curi ][curj + 1] = '0';
qu.push({curi , curj + 1});
}
}
}
int numIslands(vector<vector<char>>& grid) {
n = grid.size();
m = grid[0].size();
int res = 0;
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(grid[i][j] == '1'){
res++;
bfs(grid,i,j);
}
}
}
return res;
}
};岛屿的最大面积
class Solution {
int n,m;
int count;
void dfs(vector<vector<int>>& grid, int i, int j){
grid[i][j] =0;
if(i - 1 >= 0 && grid[i-1][j] == 1){
count++;
dfs(grid, i-1, j);
}
if(i + 1 < n && grid[i+ 1][j] == 1){
count++;
dfs(grid, i+1, j);
}
if(j-1 >= 0 && grid[i][j-1] == 1){
count++;
dfs(grid, i, j-1);
}
if(j+1 < m && grid[i][j+1] == 1){
count++;
dfs(grid, i, j+1);
}
}
public:
int maxAreaOfIsland(vector<vector<int>>& grid) {
count = 0;
int res = 0;
n = grid.size();
m = grid[0].size();
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(grid[i][j] == 1){
count++;
dfs(grid, i, j);
res = max(res, count);
count = 0;
}
}
}
return res;
}
};bfs
class Solution {
int n,m;
int count;
void bfs(vector<vector<int>>& grid, int i, int j){
queue<pair<int, int>> qu;
qu.push({i, j});
grid[i][j] = 0;
while(!qu.empty()){
pair<int, int> cur = qu.front();
qu.pop();
int curx = cur.first;
int cury = cur.second;
if(curx - 1 >= 0 && grid[curx - 1][cury] == 1){
count++;
grid[curx - 1][cury] = 0;
qu.push({curx-1, cury});
}
if(curx+1 < n && grid[curx+1][cury] == 1){
count++;
grid[curx+1][cury] = 0;
qu.push({curx+1, cury});
}
if(cury-1 >= 0 && grid[curx][cury-1] == 1){
count++;
grid[curx][cury-1] = 0;
qu.push({curx, cury-1});
}
if(cury+1 < m && grid[curx][cury+1] == 1){
count++;
grid[curx][cury+1] = 0;
qu.push({curx, cury+1});
}
}
}
public:
int maxAreaOfIsland(vector<vector<int>>& grid) {
int res = 0;
n = grid.size();
m = grid[0].size();
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(grid[i][j] == 1){
count = 1;
bfs(grid, i, j);
res = max(count, res);
}
}
}
return res;
}
};飞地的数量
该题目就是要求没有靠着边界的陆地。思路就是先从四个边界方向往内部遍历，将这些陆地变为海水。这样就可以直接排除所有的和边界相邻的陆地。那么剩下来的陆地就是要求的陆地。
class Solution {
int count;
int n, m;
void dfs(vector<vector<int>>& grid, int x, int y){
count++;
grid[x][y] = 0;
if(x - 1 >= 0 && grid[x-1][y] == 1) {
dfs(grid, x-1, y);
}
if(x+1 < n && grid[x+1][y] == 1) {
dfs(grid, x+1, y);
}
if(y-1 >= 0 && grid[x][y-1] == 1) {
dfs(grid, x, y-1);
}
if(y+1 < m && grid[x][y+1] == 1) {
dfs(grid, x, y+1);
}
}
public:
int numEnclaves(vector<vector<int>>& grid) {
n = grid.size();
m = grid[0].size();
for(int i = 0; i < n; i++){
if(grid[i][0] == 1) dfs(grid, i, 0); //先遍历每一行，从左右边界往内遍历
if(grid[i][m-1] == 1) dfs(grid, i, m-1);
}
for(int i = 0; i < m; i++){
if(grid[0][i] == 1) dfs(grid, 0, i); //再遍历行，从上下边界往内遍历
if(grid[n-1][i] == 1) dfs(grid, n-1, i);
}
count = 0;
for(int i = 0; i < n; i++){//最后就重新搜查独立陆地的面积
for(int j = 0; j < m; j++){
if(grid[i][j] == 1){
dfs(grid, i, j);
}
}
}
return count;
}
};bfs
class Solution {
int n, m;
int count;
void bfs(vector<vector<int>>& grid, int x, int y){
grid[x][y] = 0;
count++;
queue<pair<int, int>> qu;
qu.push({x, y});
while(!qu.empty()){
pair<int, int> cur = qu.front();
qu.pop();
int cur_x = cur.first;
int cur_y = cur.second;
if(cur_x-1 >= 0 && grid[cur_x-1][cur_y] == 1) {
grid[cur_x-1][cur_y] = 0;
count++;
qu.push({cur_x-1, cur_y});
}
if(cur_x+1 < n && grid[cur_x+1][cur_y] == 1){
grid[cur_x+1][cur_y] = 0;
count++;
qu.push({cur_x+1, cur_y});
}
if(cur_y-1 >=0 && grid[cur_x][cur_y-1] == 1){
grid[cur_x][cur_y-1] = 0;
count++;
qu.push({cur_x, cur_y-1});
}
if(cur_y+1 < m && grid[cur_x][cur_y+1] == 1) {
grid[cur_x][cur_y+1] = 0;
count++;
qu.push({cur_x, cur_y+1});
}
}
}
public:
int numEnclaves(vector<vector<int>>& grid) {
n = grid.size();
m = grid[0].size();
count = 0;
for(int i = 0; i < n; i++){
if(grid[i][0] == 1) bfs(grid, i, 0);
if(grid[i][m-1] == 1) bfs(grid, i, m-1);
}
for(int i = 0; i < m; i++){
if(grid[0][i] == 1) bfs(grid, 0, i);
if(grid[n-1][i] == 1) bfs(grid, n-1, i);
}
count = 0;
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(grid[i][j] == 1){
bfs(grid, i, j);
}
}
}
return count;
}
};被围绕的区域
这一题的意思就是把不毗邻边界的陆地改为海洋，而毗邻边界的陆地不变。根据上一题的思路，从边界出发，遇到陆地，改为’1‘， 然后在遍历，遇到陆地变为海洋，遇到’1‘，就变为陆地。
class Solution {
int n, m;
void dfs(vector<vector<char>>& board, int x, int y){
board[x][y] = '1';
if(x-1 >= 0 && board[x-1][y] == 'O') dfs(board, x-1, y);
if(x+1 < n && board[x+1][y] == 'O') dfs(board, x+1, y);
if(y-1 >= 0 && board[x][y-1] =='O') dfs(board, x, y-1);
if(y+1 < m && board[x][y+1] == 'O') dfs(board, x, y+1);
}
public:
void solve(vector<vector<char>>& board) {
n = board.size();
m = board[0].size();
for(int i = 0; i < n; i++){
if(board[i][0] == 'O') dfs(board, i, 0);
if(board[i][m-1] == 'O') dfs(board, i, m-1);
}
for(int i = 0; i < m; i++){
if(board[0][i] == 'O') dfs(board, 0, i);
if(board[n-1][i] == 'O') dfs(board, n-1, i);
}
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(board[i][j] == 'O') board[i][j] = 'X';
if(board[i][j] == '1') board[i][j] = 'O';
}
}
}
};太平洋大西洋水流问题
使用dfs，从海洋到陆地遍历，注意高度从低到高，要是从陆地到海洋才是从高到低
如果从陆地到海洋的角度去考虑这道问题，那么就需要以一个格子为基准，遍历整个陆地，这样的话就会出现重复遍历，时间复杂度会超时。
所有我们就从海洋到陆地的角度去考虑，并且再增加两个数组，去判断这个位置是否满足题目要求（是否是从低到高，这样水流才会流到海洋）
class Solution {
int n,m;
void dfs(vector<vector<int>>& heights, vector<vector<int>>& visited, int x, int y){
if(visited[x][y]) {
return;
}
visited[x][y] = 1;
//反向考虑，从海洋到陆地，所以这个判断条件是 <=
if(x-1 >= 0 && heights[x][y] <= heights[x-1][y]) dfs(heights, visited, x-1, y);
if(x+1 < n && heights[x][y] <= heights[x+1][y]) dfs(heights, visited, x+1, y);
if(y-1 >= 0 && heights[x][y] <= heights[x][y-1]) dfs(heights, visited, x, y-1);
if(y+1 < m && heights[x][y] <= heights[x][y+1]) dfs(heights, visited, x, y+1);
}
public:
vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
n = heights.size();
m = heights[0].size();
vector<vector<int>> result;
vector<vector<int>> pacific = vector<vector<int>>(n, vector<int>(m, 0));
vector<vector<int>> atlantic = vector<vector<int>>(n, vector<int>(m, 0));
//普通的从边界到内部遍历，分为上下和左右
for(int i = 0; i < n; i++){
dfs(heights, pacific, i, 0); // 这里是从左边界开始，传入pacific
dfs(heights, atlantic, i, m-1); // 这里是从右边界开始
}
for(int i = 0; i < m; i++){
dfs(heights, pacific, 0, i); // 从上边界开始
dfs(heights, atlantic, n-1, i); // 下边界
}
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(pacific[i][j] && atlantic[i][j]){
result.push_back({i, j});
}
}
}
return result;
}
};
323
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
