算法学习——LeetCode力扣图论篇1
797. 所有可能的路径
797. 所有可能的路径 - 力扣（LeetCode）
描述
给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）
graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。
示例
示例 1：
输入：graph = [[1,2],[3],[3],[]]
输出：[[0,1,3],[0,2,3]]
解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3
示例 2：
输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]
输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]
提示
n == graph.length
2 <= n <= 15
0 <= graph[i][j] < n
graph[i][j] != i（即不存在自环）
graph[i] 中的所有元素 互不相同
保证输入为 有向无环图（DAG）
代码解析
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void dfs(vector<vector<int>>& graph , int indnx)
{
if(indnx == graph.size()-1)
{
path.push_back(graph.size()-1);
result.push_back(path);
path.pop_back();
return;
}
for(int i=0 ; i<graph[indnx].size() ;i++)
{
path.push_back(indnx);
dfs(graph,graph[indnx][i]);
path.pop_back();
}
return;
}
vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
dfs(graph,0);
return result;
}
};
200. 岛屿数量
200. 岛屿数量 - 力扣（LeetCode）
描述
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例
示例 1：
输入：grid = [
[“1”,“1”,“1”,“1”,“0”],
[“1”,“1”,“0”,“1”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“0”,“0”,“0”]
]
输出：1
示例 2：
输入：grid = [
[“1”,“1”,“0”,“0”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“1”,“0”,“0”],
[“0”,“0”,“0”,“1”,“1”]
]
输出：3
提示
m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值为 ‘0’ 或 ‘1’
代码解析
深度优先搜索dfs
class Solution {
public:
int result = 0;
int m =0 ,n=0;
int dir[4][2] = {0,1, 0,-1 , -1,0 , 1,0};
void dfs(vector<vector<char>>& grid , vector<vector<bool>> &path , int x , int y)
{
for(int i=0 ; i<4 ;i++)
{
int next_x = x + dir[i][0];
int next_y = y + dir[i][1];
if(next_x<0||next_x>=m||next_y<0||next_y>=n) continue;
else if( path[next_x][next_y] == false && grid[next_x][next_y] == '1')
{
path[next_x][next_y] = true;
dfs(grid,path,next_x,next_y);
}
}
return;
}
int numIslands(vector<vector<char>>& grid) {
m = grid.size();
n = grid[0].size();
vector<vector<bool>> path( m , vector<bool>( n ,false) );
for(int i=0 ; i<m ;i++)
{
for(int j=0 ; j<n ;j++)
{
if(path[i][j] == false && grid[i][j] == '1')
{
result++;
path[i][j] = true;
dfs(grid,path,i,j);
}
}
}
return result;
}
};
广度优先搜索bfs
class Solution {
public:
int result = 0;
int m =0 ,n=0;
int dir[4][2] = {0,1, 0,-1 , -1,0 , 1,0};
void bfs(vector<vector<char>>& grid , vector<vector<bool>> &path , int x , int y)
{
queue<pair<int,int>> my_que;
my_que.push({x,y});
path[x][y] = true;
while(my_que.size() != 0)
{
pair<int,int> cur = my_que.front();
my_que.pop();
for(int i=0 ; i<4 ;i++)
{
int next_x = cur.first + dir[i][0];
int next_y = cur.second + dir[i][1];
if(next_x<0||next_x>=m||next_y<0||next_y>=n) continue;
else if( path[next_x][next_y] == false && grid[next_x][next_y] == '1')
{
my_que.push({next_x,next_y});
path[next_x][next_y] = true;
}
}
}
return;
}
int numIslands(vector<vector<char>>& grid) {
m = grid.size();
n = grid[0].size();
vector<vector<bool>> path( m , vector<bool>( n ,false) );
for(int i=0 ; i<m ;i++)
{
for(int j=0 ; j<n ;j++)
{
if(path[i][j] == false && grid[i][j] == '1')
{
result++;
path[i][j] = true;
bfs(grid,path,i,j);
}
}
}
return result;
}
};
695. 岛屿的最大面积
695. 岛屿的最大面积 - 力扣（LeetCode）
描述
给你一个大小为 m x n 的二进制矩阵 grid 。
岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
岛屿的面积是岛上值为 1 的单元格的数目。
计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。
示例
示例 1：
输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。
示例 2：
输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0
提示
m == grid.length
n == grid[i].length
1 <= m, n <= 50
grid[i][j] 为 0 或 1
代码解析
class Solution {
public:
int dir[4][2] = {0,1,0,-1,-1,0,1,0};
int m=0,n=0;
int result = 0;
int tmp_result = 0;
void dfs(vector<vector<int>>& grid , vector<vector<bool>> &path , int x ,int y)
{
for(int i=0 ; i<4 ;i++)
{
int next_x = x + dir[i][0];
int next_y = y + dir[i][1];
if(next_x<0 || next_x>=m || next_y<0 || next_y>=n) continue;
if(grid[next_x][next_y] == 1 && path[next_x][next_y] == false)
{
tmp_result++;
path[next_x][next_y] = true;
dfs(grid,path,next_x,next_y);
}
}
}
int maxAreaOfIsland(vector<vector<int>>& grid) {
m = grid.size();
n = grid[0].size();
vector<vector<bool>> path(m , vector<bool>( n , false ));
for(int i=0 ; i<m ;i++)
{
for(int j=0 ; j<n ;j++)
{
if(grid[i][j] == 1 && path[i][j] == false)
{
path[i][j] = true;
tmp_result = 1;
dfs(grid,path,i,j);
if(tmp_result > result) result =tmp_result;
}
}
}
return result;
}
};
