树：深度优先遍历、广度优先遍历相关

目录

207. 课程表

279. 完全平方数

399. 除法求值

437. 路径总和 III

200. 岛屿数量

---

深度遍历有线图相关：

void dfs(vector<vector<int>>& grid, vector<vector<bool>> &vis , int i, int j){
    vector<pair<int, int>> dir = {
  {-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    // grid[i][j] = '0';
    vis[i][j] = true;
    int m = grid.size(), n = grid[0].size();
    for(int k = 0; k < 4; k++){
        int new_i = i + dir[k].first, new_j = j + dir[k].second;
        if(new_i >= 0 && new_i < m && new_j >= 0 && new_j < n && !vis[new_i][new_j] && grid[new_i][new_j] == '1'){
            dfs(grid, new_i, new_j);
        }
    }
}

深度优先遍历模板树相关：

void dfs(int u, int v, vector<vector<pair<int, double>>> edges, vector<double> &out){
        //对u节点进行dfs遍历，v是目标节点
        if(u == v)
            return;
        for(const auto& node_val: edges[u]){
            int y = node_val.first;
            double val = node_val.second;
            if(out[y] < 0){
                out[y] = out[u] * val;
                dfs(y, v, edges, out);
            }
        }
        //此处的return表示的是当前节点已经将其相邻的节点扫描完毕，直接返回即可
        return;
    }

广度优先遍历图相关

void bfs(vector<vector<char>>& grid, vector<vector<bool>> &vis, int i, int j){
    cout << i << " - " << j << endl;
    vis[i][j] = true;
    queue<pair<int, int>> que;
    que.push(make_pair(i, j));
    vector<pair<int, int>> dir = {
  {-1, 0}, {1, 0}, {0, 1}, {0, -1}};
    int m = grid.size(), n = grid[0].size();
    while(!que.empty()){
        int x = que.front().first, y = que.front().second;
        // vis[x][y] = true;
        que.pop();
        for(int k = 0; k < 4; k++){
            int new_x = x + dir[k].first, new_y = y + dir[k].second;
            if(new_x >= 0 && new_x < m && new_y >= 0 && new_y < n && grid[new_x][new_y] == '1' &&!vis[new_x][new_y]){
                que.push(make_pair(new_x, new_y));
                vis[new_x][new_y] = true;
            }
        }
    }
}

广度遍历优先模板： 

queue<int> que;
int u = str_index[q[0]], v = str_index[q[1]];
vector<double> out(index, -1.0);
out[u] = 1.0;
que.push(u);
while(!que.empty() && out[v] < 0){
    //队列不为空并且目标节点的值还没有被计算出来
    u = que.front();
    que.pop();
    for(const auto& node_val:edges[u]){
        int y = node_val.first;
        double val = node_val.second;
        if(out[y] < 0){
            out[y] = out[u] * val;
            que.push(y);
        }
    }
}

207. 课程表

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程  bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。
示例 2：

输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

可参考判断图中是否有环的三种方法 

#include "bits/stdc++.h"

using namespace std;

class Solution {
private:
    vector<int> vis;//标记访问状态,0:未被访问,1:正在访问中,2:访问完毕
    vector< vector<int>> adj;//邻接矩阵
    bool valid = true;//及时止损的作用，判断是否有环，有环直接返回，无需继续遍历
public:
    void dfs(int node){
        vis[node] = 1;
        for(const auto& now: adj[node]){
            //访问node节点出度的指向的节点
            if(vis[now] == 0)
                dfs(now);
            else if(vis[now] == 1){
                //当前后继节点正在被搜索，说明存在环
                valid = false;
                return;
            }
        }
        vis[node] = 2;
    }
    bool canFinish_dfs(int numCourses, vector<vector<int>>& prerequisites) {
        /*判断生成的图存不存在环
        可参考：https://blog.csdn.net/qq