完整教程:图论&回溯
图论
200.岛屿数量DFS
给你一个由 ‘1’(陆地)和 ‘0’(水)组成的的二维网格,请你计算网格中岛屿的数量。岛屿总是被水包围,并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外,你可以假设该网格的四条边均被水包围。
深度优先遍历:用一个visited数组标记所有访问过的地方,遍历图,遇到第一个陆地且没被访问过,就用深搜遍历此岛屿的全部陆地。
class Solution {
private:
int dir[4][2] = {
0
, 1
, 1
, 0
, -1
, 0
, 0
, -1
}
;
void dfs(vector<vector<
bool>>
& visit, vector<vector<
char>>
& grid,
int x,
int y){
for(
int i = 0
; i <
4
; i++
) {
int nextx = x + dir[i][0]
;
int nexty = y + dir[i][1]
;
if(nextx <
0 || nextx >= grid.size(
) || nexty <
0 || nexty >= grid[0].size(
)
)
continue
;
if(!visit[nextx][nexty] && grid[nextx][nexty] == '1'
) {
visit[nextx][nexty] = true
;
dfs(visit, grid, nextx, nexty)
;
}
}
}
public:
int numIslands(vector<vector<
char>>
& grid) {
int n = grid.size(
)
, m = grid[0].size(
)
;
vector<vector<
bool>> visit = vector<vector<
bool>>(n, vector<
bool>(m, false
)
)
;
int result = 0
;
for(
int i = 0
; i < n; i++
) {
for(
int j = 0
; j < m; j++
) {
if(!visit[i][j] && grid[i][j] == '1'
) {
result++
;
visit[i][j] = true
;
dfs(visit, grid, i, j)
;
}
}
}
return result;
}
}
;
994.腐烂的橘子BFS
在给定的 m x n 网格 grid 中,每个单元格可以有以下三个值之一:
值 0 代表空单元格;
值 1 代表新鲜橘子;
值 2 代表腐烂的橘子。
每分钟,腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。
返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能,返回 -1 。
class Solution {
public:
int orangesRotting(vector<vector<
int>>
& grid) {
int n = grid.size(
)
, m = grid[0].size(
)
;
queue<pair<
int
,
int>> q;
int fresh = 0
;
for(
int i = 0
; i < n; i++
) {
for(
int j = 0
; j < m; j++
) {
if(grid[i][j] == 2
) {
q.push({
i,j
}
)
;
}
else
if(grid[i][j] == 1
) {
fresh++
;
}
}
}
int time = 0
;
int dir[4][2] = {
1
, 0
, 0
, 1
, -1
, 0
, 0
, -1
}
;
while(!q.empty(
) && fresh >
0
) {
int size = q.size(
)
;
while(size--
) {
auto [x, y] = q.front(
)
; q.pop(
)
;
for(
int i = 0
; i <
4
;i++
) {
int nx = x + dir[i][0]
;
int ny = y + dir[i][1]
;
if(nx <
0 || ny <
0 || nx >= grid.size(
) || ny >= grid[0].size(
) || grid[nx][ny] != 1
)
continue
;
grid[nx][ny] = 2
;
q.push({
nx,ny
}
)
;
fresh--
;
}
}
time++
;
}
return fresh == 0 ? time : -1
;
}
}
;
207.课程表
你这个学期必须选修 numCourses 门课程,记为 0 到 numCourses - 1 。
在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出,其中 prerequisites[i] = [ai, bi] ,表示如果要学习课程 ai 则 必须 先学习课程 bi 。
例如,先修课程对 [0, 1] 表示:想要学习课程 0 ,你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习?如果可以,返回 true ;否则,返回 false 。
本题可约化为: 课程安排图是否是 有向无环图(DAG)。
方法一:入度表(广度优先遍历)
算法流程:
统计课程安排图中每个节点的入度,生成 入度表 indegrees。
借助一个队列 queue,将所有入度为 0 的节点入队。
当 queue 非空时,依次将队首节点出队,在课程安排图中删除此节点 pre:
并不是真正从邻接表中删除此节点 pre,而是将此节点对应所有邻接节点 cur 的入度 −1,即 indegrees[cur] -= 1。
当入度 −1后邻接节点 cur 的入度为 0,说明 cur 所有的前驱节点已经被 “删除”,此时将 cur 入队。
在每次 pre 出队时,执行 numCourses–;
若整个课程安排图是有向无环图(即可以安排),则所有节点一定都入队并出队过,即完成拓扑排序。换个角度说,若课程安排图中存在环,一定有节点的入度始终不为 0。
因此,拓扑排序出队次数等于课程个数,返回 numCourses == 0 判断课程是否可以成功安排。
class Solution {
public:
bool canFinish(
int numCourses, vector<vector<
int>>
& prerequisites) {
vector<vector<
int>>
adjacency(numCourses)
;
vector<
int>
indegrees(numCourses, 0
)
;
queue<
int> q;
for(
const
auto& pair : prerequisites) {
int course = pair[0]
, pre = pair[1]
;
indegrees[course]++
;
adjacency[pre].push_back(course)
;
}
for(
int i = 0
; i < indegrees.size(
)
; i++
) {
if(indegrees[i] == 0
) q.push(i)
;
}
while(!q.empty(
)
){
int pre = q.front(
)
; q.pop(
)
;
numCourses--
;
for(
int i = 0
; i < adjacency[pre].size(
)
; i++
) {
if(--indegrees[adjacency[pre][i]] == 0
)
q.push(adjacency[pre][i]
)
;
}
}
return numCourses == 0
;
}
}
;
208.前缀树
Trie(发音类似 “try”)或者说 前缀树 是一种树形数据结构,用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景,例如自动补全和拼写检查。
请你实现 Trie 类:
Trie() 初始化前缀树对象。
void insert(String word) 向前缀树中插入字符串 word 。
boolean search(String word) 如果字符串 word 在前缀树中,返回 true(即,在检索之前已经插入);否则,返回 false 。
boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ,返回 true ;否则,返回 false 。路漫漫我不畏;
class Trie {
private:
bool isEnd;
Trie* next[26]
;
public:
Trie(
) {
isEnd = false
;
memset(next, 0
,
sizeof(next)
)
;
}
void insert(string word) {
Trie* node =
this
;
for(
char ch : word){
if(node->next[ch - 'a'] == NULL
) {
node->next[ch - 'a'] =
new Trie(
)
;
}
node = node->next[ch - 'a']
;
}
node->isEnd = true
;
}
bool search(string word) {
Trie* node =
this
;
for(
char ch : word) {
node = node->next[ch - 'a']
;
if(node == NULL
)
return false
;
}
return node->isEnd;
}
bool startsWith(string prefix) {
Trie* node =
this
;
for(
char ch : prefix) {
node = node->next[ch - 'a']
;
if(node == NULL
)
return false
;
}
return true
;
}
}
;
/**
* Your Trie object will be instanti`ated and called as such:
* Trie* obj = new Trie();
* obj->insert(word);
* bool param_2 = obj->search(word);
* bool param_3 = obj->startsWith(prefix);
*/
全排列
46. 全排列
给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
class Solution {
private:
vector<
int> path;
vector<vector<
int>> result;
void backtracking(vector<
int>
& nums, vector<
bool>
& used){
if(path.size(
) == nums.size(
)
) {
result.push_back(path)
;
return
;
}
for(
int i = 0
; i < nums.size(
)
; i++
){
if(used[i] == true
)
continue
;
path.push_back(nums[i]
)
;
used[i] = true
;
backtracking(nums, used)
;
used[i] = false
;
path.pop_back(
)
;
}
}
public:
vector<vector<
int>>
permute(vector<
int>
& nums) {
path.clear(
)
;
result.clear(
)
;
vector<
bool>
used(nums.size(
)
, false
)
;
backtracking(nums,used)
;
return result;
}
}
;
78.子集
给你一个整数数组 nums ,数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。
子集问题、组合问题、分割问题可以抽象成树,组合和分割是收集树的叶子结点,而子集是找树的所有结点。
class Solution {
public:
vector<
int> path;
vector<vector<
int>> result;
void backtracking(vector<
int>
& nums,
int startIndex) {
result.push_back(path)
;
for(
int i = startIndex; i < nums.size(
)
; i++
) {
path.push_back(nums[i]
)
;
backtracking(nums, i + 1
)
;
path.pop_back(
)
;
}
}
vector<vector<
int>>
subsets(vector<
int>
& nums) {
backtracking(nums, 0
)
;
return result;
}
}
;
17. 电话号码的字母组合
给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
class Solution {
private:
const string letterMap[10] = {
""
,
""
,
"abc"
,
"def"
,
"ghi"
,
"jkl"
,
"mno"
,
"pqrs"
,
"tuv"
,
"wxyz"
}
;
public:
vector<string> result;string s;void backtracking(const string& digits,int index) {if(digits.size() == index) {result.push_back(s);return;}int digit = digits[index] - '0';string letter = letterMap[digit];for(int i = 0; i < letter.size(); i++){s.push_back(letter[i]);backtracking(digits, index + 1);s.pop_back();}}vector<string>letterCombinations(string digits) {s.clear();result.clear();if(digits.size() == 0)return result;backtracking(digits, 0);return result;}};