树的dfs与dfs

kokomi&ayaka

已于 2023-05-03 20:41:00 修改

阅读量65

点赞数

分类专栏：华为机试备考蓝桥杯国赛备考文章标签：深度优先算法图论

于 2023-04-27 01:12:16 首次发布

本文链接：https://blog.csdn.net/q12q31w/article/details/130367190

版权

华为机试备考同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

蓝桥杯国赛备考

6 篇文章 0 订阅

订阅专栏

树/图的dfs与bfs

树/图的存储
- 链式前向星法
- - 技巧！
树的dfs
树的bfs
邻接矩阵的写法
参考文献

树/图的存储

链式前向星法

用链表实现邻接表的存储

cpp模板

int h[N],e[M],ne[M],idx;
int w[N];//边权
//向图中添加有向边
void add(int a, int b, int c){
	e[idx] = b;
	ne[idx] = h[a];
	w[idx] = c;
	h[a] = idx++;
}

int main(){
	memset(h, -1, sizeof h);//必须初始化！
}

技巧！

在建边时，可能会遇到以某一节点的有多条边，但这些边的另一节点并不是按序号大小输入的，如果我希望这些节点在邻接表中按顺序存储，该怎么做？

如果你希望链式前向星邻接表中的边按照节点顺序存储，可以在添加边的过程中对它们进行排序。这里给出一种利用插入排序的方法实现这个功能：

在添加一条从节点 a 到节点 b 的边之前，先找到节点 a 的邻接表中应该插入的位置。
将新边插入到找到的位置，并更新相应的头指针和下一条边指针。
以下是一个按节点顺序添加边的 add 函数实现：

void add(int a, int b) {
    // 查找插入位置
    int prev = -1, cur = h[a];
    while (cur != -1 && e[cur] < b) {
        prev = cur;
        cur = ne[cur];
    }

    // 插入新边
    e[idx] = b;
    ne[idx] = cur;

    // 更新头指针或下一条边指针
    if (prev == -1) {
        h[a] = idx;
    } else {
        ne[prev] = idx;
    }

    idx++;
}

const int N = 1e4+10, M = 2 * N;
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int c) {
    // 查找插入位置
    int prev = -1, cur = h[a];
    while (cur != -1 && e[cur] < b) {
        prev = cur;
        cur = ne[cur];
    }

    // 插入新边
    e[idx] = b;
    w[idx] = c; // 存储边权值
    ne[idx] = cur;

    // 更新头指针或下一条边指针
    if (prev == -1) {
        h[a] = idx;
    } else {
        ne[prev] = idx;
    }

    idx++;
}

应用：

存各种图都很适合，但不能快速查询一条边是否存在，也不能方便地对一个点的出边进行排序；
优点是边是带编号的，有时会非常有用

树的dfs

cpp模板

int st[N];
void dfs(int u){
	st[u] = true;
	for(int i = h[u]; i != -1; i = ne[i]){
	int j = ne[i];
	if(!st[j]){
		dfs(j);
	}
}

例题

树的重心

acwing基础课
这题关于树的重心的定义有点绕，一开始也理解了很久。如何去求：把某个点删除之后的剩余的连通块的最大值？
深度优先遍历有一个好处是：我们可以递归地求出每个点的子树的大小。上面的连通块的点数就是b $n - 子树的大小$ （很神奇，上面的点一定是连通的吗？如何证明？）
这题感觉思想有点像树上dp

AC代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+10, M = N * 4;
int n, m;
int h[N], e[M], ne[M], idx;
int st[N];
void add(int a, int b){
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}
int ans = 1e5+10;
//以u为根的子树的点的数量
int dfs(int u){
    st[u] = true;
    int sum = 1, res=0;
    for(int i = h[u]; i != -1; i = ne[i]){
        int j = e[i];
        if(!st[j]){
            int x = dfs(j);
            res = max(x, res);//x为子树大小，也是删去u节点后的一个连通块
            sum += x; //表示u为根节点的子树的数量
        } 
    }
    res = max(n-sum, res);
    
    ans = min(res, ans);
    return sum;
}
int main(){
    memset(h, -1, sizeof h);
    cin >> n;
    for(int i=0; i<n-1; i++){
        int a, b;
        cin>>a>>b;
        add(a, b),add(b, a);
    }
    dfs(1);
    cout << ans;
    return 0;
}

华子4.12 实习笔试第二题

获取最多食物
AC code

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int h[N], e[N], ne[N], value[N], idx;
int va[N];
int start;
int res = -1000;
void add(int a, int b,int v){
    e[idx] = b;
    value[idx] = v;
    ne[idx] = h[a];
    h[a] = idx++;
}
int dfs(int u){
    int max1 = va[u];
    for(int i = h[u]; i != -1; i = ne[i]){
        int v = e[i];
        max1 = max(max1, dfs(v)+va[u]);
    }
    res = max(max1, res);
    return max1;
}
int main(){
    int n;
    cin >> n;
    memset(h, -1, sizeof h);
    for(int i = 0; i < n; i++){
        int id, pid, value;
        cin >> id >> pid >> value;
        add(++pid,++id, value);
        va[id] = value;
    }
    va[0] = -1000;
    dfs(0);
    cout << res;
    return 0;
}

树的bfs

cpp模板

void bfs(int u){
	queue<int> q;
	st[u] = true;
	q.push(u);
	while(q.size()){
		auto t = q.front();
		q.pop();
		for(int i = h[t]; i != -1; i = ne[i]){
			int v = e[i];
			if(!st[i]){
				st[v] = true;
				q.push(v);
			}
		}
	}
}

此外，我们也可以在bfs的过程中记录一些额外的信息，比如可以开一个数组d记录从起点到某个节点的最短距离，也可以开一个数组p记录从起点到某个节点的路径。例如：

void bfs(int u){
	queue<int> q;
	st[u] = true, p[u] = -1;
	while(q.size(){
		auto t = q.front();
		q.pop();
		for(int i = h[t]; i != -1; i = ne[i]){
			int v = e[i];
			if(!st[v]){
				st[v] = true;
				q.push(v);
				d[v] = d[t] + 1;
				p[v] = t;
			}
		}
	}
}

假设终点是x,那么从起点u到x的最短距离就是 $d [x]$ ,我们也可以从p数组还原出这条路径：

vector<int> restore(int x){
	vector<int> path;
	for(int v = x; v != -1; v = p[v]){
		path.push_back(v);
	}
	reverse(path.begin(), path.end());
	return path;
}

例题

图中点的层次

acwing847
板子题，没什么好说的

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int N = 1e5+10, M = 2*N;
int h[N], e[M], ne[M], idx;
int n, m;
int d[N];
int st[N];
void add(int a, int b){
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}
void bfs(int u){
    queue<int> q;
    st[u] = true;
    q.push(u);
    d[u] = 0;
    while(q.size()){
        auto t = q.front();
        q.pop();
        for(int i = h[t]; i != -1; i = ne[i]){
            int j = e[i];
            if(!st[j]){
                st[j] = true;
                q.push(j);
                d[j] = d[t] + 1;
            }
        }
    }
}
int main(){
    cin >> n >> m;
    memset(h, -1, sizeof h);
    memset(d, -1, sizeof d);
    while(m--){
        int a, b;
        cin >> a >>b;
        add(a, b);
    }
   
    bfs(1);
    cout << d[n] <<endl;
    return 0;
}

树上逃离

华为2023.4.19 机试 2
在这里插入图片描述
塔子哥题库1196
dfs的做法

#include<bits/stdc++.h>
#include <cstring>
using namespace std;
//我觉得这题不同点在于点是可以重复访问的，但不能会走
//所以dfs处理方式有所不同，记录一下父节点
const int N = 1e4+10 , M = N * 2;
int h[N], e[M], ne[M], idx;
int n, m, d;
int duche[N];//记录堵车点
vector<int> path;
vector<int> s;
void add(int a, int b){
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
void dfs(int u, int fa){
    //退出循环条件: 这里无需
    s.push_back(u);//将u节点加入路径
    int flag = 1;//是否到达叶子节点
    for(int i = h[u]; i != -1; i = ne[i]){
        int j = e[i];
        if(j == fa) continue;//不能回访父节点
        flag = 0;//说明还没到达叶子节点
        if(duche[j]) continue;//此节点无法通过
        dfs(j, u);
    }
    if(flag){
        //已经到达叶子节点，更新一下最小路径
        if(path.empty()||s.size() < path.size()) path = s;
        else if(s.size() == path.size()){//检查是否字典序更小
            for(int i = 0; i < s.size(); i++){
                if(s[i] > path[i]) break;
                else if(s[i] < path[i]) {
                    path = s;
                    break;
                }
            }
        }
    }
    s.pop_back();//回溯
}
int main(){
    memset(h, -1, sizeof h);
    memset(duche, 0, sizeof duche);
    cin >> n >> m;
    while(m--){
        int x, y;
        cin >> x >> y;
        add(x, y), add(y, x);
    }
    cin >> d;
    while(d--){
        int x;
        cin >> x;
        duche[x] = 1;
    }
    dfs(0, 0);
    if(path.empty()) cout<<"NULL";
    else{
        for(int i = 0; i < path.size() - 1; i++){
            cout << path[i] << "->";
        }
        cout << path.back();
    }
}

bfs做法

#include<bits/stdc++.h>
using namespace std;

int n, m ,k;
const int N = 1e4+10, M = 2 * N;
int h[N], e[M], ne[M], idx;
void add(int a, int b){// 节点按顺序排列
    // e[idx] = b;
    // ne[idx] = h[a];
    // h[a] = idx++;
    //  查找插入位置
    int prev = -1, cur = h[a];
    while (cur != -1 && e[cur] < b) {
        prev = cur;
        cur = ne[cur];
    }

    // 插入新边
    e[idx] = b;
    ne[idx] = cur;

    // 更新头指针或下一条边指针
    if (prev == -1) {
        h[a] = idx;
    } else {
        ne[prev] = idx;
    }

    idx++;
}
// 判断是否为叶子节点，叶子节点出度为1，只有父节点一条边
bool is_leaf(int u) {
    int edge_count = 0;
    for (int i = h[u]; i != -1; i = ne[i]) {
        edge_count++;
    }
    return edge_count == 1;
}
int st[N];//不可访问相当于以及被访问过
int p[N];
vector<int> path;
int bfs(int u){
    queue<int> q;
    if(st[u]) return -1;//细节！注意卡边界条件！
    p[u] = -1;
    q.push(u);
    st[u] = true;
    while(q.size()){
        int t = q.front();      
        q.pop();
        if(is_leaf(t)) return t;
        for(int i = h[t]; i != -1; i = ne[i]){
            int j = e[i];
            if(!st[j]){
                p[j] = t;
                st[j] = true;
                q.push(j);
            }
        }
    }
    return -1;
}
int main(){
    memset(h, -1, sizeof h);
    cin >> n >> m ;
    while(m--){
        int x, y;
        cin >> x >> y;
        add(x, y), add(y, x);
    }
    cin>>k;
    while(k--){
        int x;
        cin >> x;
        st[x] = true;
    }
    int t = bfs(0);
    if(t == -1) cout<<"NULL";
    else{
        for(int i = t; i != -1; i = p[i]){
            path.push_back(i);
        }
        reverse(path.begin(), path.end());
        for(int i = 0; i < path.size() - 1; i++){
            cout << path[i] << "->";
        }
        cout << path.back();
    }
    
}

邻接矩阵的写法

虽然链式前向星法用起来真的很爽，但是为了保险起见，至少还应该学邻接矩阵/邻接表的写法一种。
下面是

参考文献

一文搞懂图的存储与遍历

kokomi&ayaka

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
树的dfs与dfs

此外，我们也可以在bfs的过程中记录一些额外的信息，比如可以开一个数组d记录从起点到某个节点的最短距离，也可以开一个数组p记录从起点到某个节点的路径。在建边时，可能会遇到以某一节点的有多条边，但这些边的另一节点并不是按序号大小输入的，如果我希望这些节点在邻接表中按顺序存储，该怎么做？如果你希望链式前向星邻接表中的边按照节点顺序存储，可以在添加边的过程中对它们进行排序。如何去求：把某个点删除之后的剩余的连通块的最大值？在添加一条从节点 a 到节点 b 的边之前，先找到节点 a 的邻接表中应该插入的位置。
复制链接

扫一扫