拓扑排序BFS DFS

本文介绍了拓扑排序的两种方法:BFS(广度优先搜索)和DFS(深度优先搜索)。BFS通过优先队列实现,优先处理入度为零的节点。DFS则结合入度数组,确保每次只访问未访问过且入度为0的节点,生成字典序最小的拓扑序列。

BFS

整个图中按照各个路径的优先级先后进行,将同一优先级的路径处理完了之后再进行下一优先级的处理

具体做法

输入路径时初始化每个点的入度大小,现将入度为零的点加入优先对列,然后每一步输出队列首元素,并且把与队首元素相邻的元素入度减一,这样就做到了按照优先级的移动,直到队列里无元素,这样所有输出的元素就是一个拓扑序列。

代码一:用二维数组代替队列直接操作 较好理解

#include<iostream>
#include<algorithm>
using namespace std;
int g[maxn][maxn];
int inrt[maxn];

void solve(){
	for(i=1;i<=n;i++)
		for(j=1;i<=i;j++)
		{
			if(inrt[j]==0)
			 inrt=-1;
			if(i==n) cout<<j<<endl;
			else     cout<<j<<" ";
			for(k=1;k<=j;k++){
			    if(g[j][k]) inrt[k]--;
			}
		}
}
int main(){
    int n,x,y;
	cin>>n;
for(i=1;i<=n;i++)
{
	cin>>x>>y;
	g[x][y]=1;
	g[y][x]=1;
	inrt[y]++;
}
    solve();
	return 0;
}

二:

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = 10000;
struct Node{
    int indegree;
    int num;     
    int id;      
}N[maxn];
int V,E;
int d[maxn][maxn];
void Init()
{
    memset(d,0,sizeof(d));
    for(int i=0; i<V; i++)
    {
        N[i].indegree = 0;
        N[i].num = 0;
        N[i].id = i;
    }
    return;
}
int main()
{
    scanf("%d%d",&V,&E);
    Init();
    int s,t;
    for(int i=0; i<E; i++)
    {
        scanf("%d%d",&s,&t);
        d[s][t] = 1;
        N[t].indegree++;
    }
    int counter = 0;
    queue<Node> q;
    for(int i=0; i<V; i++)
    {
        if(!N[i].indegree)
        {
            q.push(N[i]);
        }
    }
    while(!q.empty){
		Node v=q.front();
		q.pop();
		N[v.id]=counter++;
        for(i=0;i<V;i++)
		{
			if(d[v.id][i])
			{
				N[i].indegree()--;
				if(N[i].indegree()]
				{
                   q.push(N[i]);
				}
			}
		}
}
    for(int i=0; i<V; i++)
    {
        if(N[i].num==i)
		 cout<<N[i].id<<" ";
    }
    return 0;
}

DFS:

根据dfs的规则,从一条路开始探索直到最深,然后再逐层回退,。这个过程正好可以表现出点之间的优先级关系

在dfs的基础上添加表示每个点的入度的数组,那么就是每次for循环只有没访问过且入度为0的节点更新到答案数组中,每次dfs之后都将标志清空,将入度回复,这样和全排列一样最后可以生成按字典序由小到大的拓扑序列

 


#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
const int maxn=?;
int n,m;
vector<int> G[maxn];
int ans[maxn],in[maxn];
bool vis[maxn];
void dfs(int x){ 
    if(x==n+1){
        for(int i=1;i<=n;i++)
         printf("%d%c",ans[i],i==n?'\n':' ');
        return;
    }
    for(int i=1;i<=n;i++){                                                                                                                                                                                                                       
        if(!vis[i]&&!in[i]){
            ans[x]=i;
            vis[i]=1;
            for(int j=0;j<G[i].size();j++) in[G[i][j]]--;
            dfs(x+1);         
            vis[i]=0; 
            for(int j=0;j<G[i].size();j++) 
			in[G[i][j]]++;
        }

    }
}

int main()
{
    int a,b;
    cin>>n>>m;
    memset(vis,0,sizeof vis);
    for(int i=1;i<=n;i++) 
        G[i].clear();
    while(m--){
        scanf("%d%d",&a,&b);
        G[a].push_back(b);
        in[b]++;
    }
    dfs(1);
    return 0;
}

 

### BFSDFS 算法的区别及使用场景 BFS(广度优先搜索)和 DFS(深度优先搜索)是两种常见的图遍历算法,它们在思想、实现方式以及适用场景上存在显著差异。 #### 1. **基本思想** - **BFS** 是一种逐层扩展的搜索方式,从起始节点出发,优先访问距离当前节点最近的节点。这种特性使得 BFS 具有最短路径性质,适用于寻找无权图中的最短路径[^2]。 - **DFS** 是一种沿着路径深入的搜索方式,从起始节点出发,尽可能深地探索每个分支,直到无法继续前进时才回溯。这种特性使得 DFS 更适合探索所有可能的路径。 #### 2. **数据结构** - **BFS** 使用队列(Queue)来管理待访问的节点,确保先访问的节点的邻居节点也会优先被访问。 - **DFS** 使用栈(Stack)或递归实现,递归方式更为常见,但容易导致栈溢出。 #### 3. **时间与空间复杂度** - **BFS** 和 **DFS** 的时间复杂度均为 $O(V + E)$,其中 $V$ 是顶点数,$E$ 是边数。 - **BFS** 的空间复杂度通常较高,因为它需要存储每一层的所有节点;而 **DFS** 的空间复杂度取决于递归深度,通常在树的深度较小时表现更好。 #### 4. **适用场景** - **BFS** 更适合以下情况: - 寻找无权图中的最短路径。 - 层次遍历问题,例如按层打印二叉树。 - 需要优先访问距离较近的节点的问题,例如社交网络中查找最近的朋友。 - **DFS** 更适合以下情况: - 探索所有可能的路径,例如迷宫问题。 - 需要回溯的场景,例如图的连通性判断。 - 深度优先的特性使得它在某些问题中更容易实现,例如拓扑排序、判断图中是否存在环。 #### 5. **示例代码** 以下是 **BFS** 和 **DFS** 的简单实现示例: **BFS 实现** ```python from collections import deque def bfs(graph, start): visited = set() queue = deque([start]) visited.add(start) while queue: node = queue.popleft() print(node) for neighbor in graph[node]: if neighbor not in visited: visited.add(neighbor) queue.append(neighbor) ``` **DFS 实现** ```python def dfs(graph, start, visited=None): if visited is None: visited = set() visited.add(start) print(start) for neighbor in graph[start]: if neighbor not in visited: dfs(graph, neighbor, visited) ``` #### 6. **总结** - **BFS** 更适合寻找最短路径或层次遍历问题,而 **DFS** 更适合探索所有可能路径或需要回溯的场景。 - **BFS** 使用队列实现,**DFS** 使用栈或递归实现。 - 在实际应用中,选择哪种算法取决于具体问题的需求和数据结构的特性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值