图的BFS&DFS

#include<iostream>
using namespace std;
#include<vector>
#include<queue>

struct node {
    int number;
    char val;
};


int main() {
    int n;//节点数量
    cin >> n;
    vector<node>graphNode(n);//n个结点
    for (int i = 0; i < n; i++) {
        char data;
        cin >> data;
        node Node;
        graphNode[i].val = data;
        graphNode[i].number = i;
    }

    int m;//边的数量
    cin >> m;
    vector<vector<int>>neighbor(n);//声明包含n个一维向量的二维向量neighbor
    for (int i = 0; i < m; i++) {
        int x, y;
        cin >> x >> y;
        neighbor[x].push_back(y);
        neighbor[y].push_back(x);
    }

    queue<node>q;
    vector<bool> visit(n);
    for (int i = 0; i < n; i++) visit[i] = false;
    for (int j = 0; j < n; j++) {
        q.push(graphNode[j]);
        while (q.empty() == false) {
            node cur = q.front();
            if (visit[cur.number] == false)
            {
                cout << cur.val << " ";
                visit[cur.number] = true;
            }
            q.pop();
            for (int i = 0; i < neighbor[cur.number].size(); i++) {
                if (visit[neighbor[cur.number][i]] == false)
                    q.push(graphNode[neighbor[cur.number][i]]);
            }
        }
    }
    return 0;
}

LeetCode1466 重新规划线路

/*
 * @lc app=leetcode.cn id=1466 lang=cpp
 *
 * [1466] 重新规划路线
 */

// @lc code=start
#include<iostream>
#include<vector>
#include<queue>
using namespace std;

class Solution {
public:
    int minReorder(int n, vector<vector<int>>& connections) {
        vector<vector<pair<int,int>>> tree(n);//声明包含n个一维向量的二维向量tree
        for(int i=0;i<connections.size();i++){
            tree[connections[i][0]].emplace_back(connections[i][1],1);
            tree[connections[i][1]].emplace_back(connections[i][0],0);
        }
        vector<bool> visit(n);
        for(int i=0;i<n;i++) visit[i]=false;
        queue<int> q;
        q.push(0);
        int res=0;
        /*
        while(q.empty()==false){
            int node=q.front();
            q.pop();
            for(auto &neighbor:tree[node]){
                if(visit[neighbor.first])continue;
                visit[neighbor.first]=true;
                q.push(neighbor.first);
                if(neighbor.second==1)res++;
            }

        }
        */
        while(q.empty()==false){
            int cur=q.front();
            if(visit[cur]==false){
                visit[cur]=true;
            }
            q.pop();
            for(int i=0;i<tree[cur].size();i++){
                if(visit[tree[cur][i].first]==false) {
                    q.push(tree[cur][i].first);
                    if(tree[cur][i].second==1)res++;
                }
            }
       }
        return res;
    }
};

LeetCode2368 受限条件下可到达节点的数目

class Solution {
vector<vector<int>> g;
public:
     int dfs(int u,int fa){
        int cnt=1;
        for(int v:g[u]){
            if(v!=fa){
                cnt+=dfs(v,u);
            }
        }
        return cnt;
    }
    int reachableNodes(int n, vector<vector<int>>& edges, vector<int>& restricted) {
        vector<bool> isr(n,false);
        for(int x:restricted){
            isr[x]=true;
        }
        g.resize(n);
        for(auto& v:edges){
            int from=v[0],to=v[1];
            if(isr[from]==false&&isr[to]==false){
                g[from].push_back(to);
                g[to].push_back(from);
            }
        }
        return dfs(0,-1);

    }
};