用topsort写有向无环图的最长路

该代码段展示了一个用C++编写的程序,用于处理有向图并执行拓扑排序。程序首先初始化图结构,然后通过添加边并设置权重构建图。接下来,它执行两次拓扑排序,一次从源节点开始计算所有节点的最大距离,另一次计算最短路径。如果从源到目标的最短路径大于等于负无穷的一半,则输出路径距离,否则输出-1表示无路径可达。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

#include<iostream>
#include<unordered_map>
#include<vector>
#include<deque>
#include<algorithm>
#include<map>
#include<set>
#include<cstring>
#include<cmath>
#include<queue>
#include<stack>
#define int  long long

using namespace std;
typedef  long long ll;
const int N=4e5+10;
const int INF=0x3f3f3f;
typedef pair<ll,int>PII;
int n,m;
int h[N],ne[N],e[N],idx;
int din[N],w[N],dist[N];
bool st[N];
void init(){
	memset(h,-1,sizeof h);
	memset(dist,-INF,sizeof dist);
	idx=0;
}

void add(int h[],int a,int b,int c){
	e[idx]=b;
	w[idx]=c;
	ne[idx]=h[a];
	h[a]=idx++;
}

void topsort(bool flag){
	queue<int>q;
	for(int i=2;i<=n&&flag;i++){
		if(!din[i]){
			q.push(i);
		}
	}
	if(!flag){
		q.push(1);
		dist[1]=0;
	}
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int i=h[u];~i;i=ne[i]){
			int v=e[i];
			din[v]--;
//			cout<<"u = "<<u<<" v = "<<v<<endl;
			if(!flag)dist[v]=max(dist[u]+w[i],dist[v]);
//			cout<<dist[v]<<endl;
			if(!din[v]){
				q.push(v);
			}
		}
	}
}

void solve(){
	init();
	int a,b,c;
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		scanf("%lld %lld %lld",&a,&b,&c);
		add(h,a,b,c);
		din[b]++;
	}
	topsort(1);
	topsort(0);
	if(dist[n]>=-INF/2)cout<<dist[n]<<endl;
	else cout<<-1<<endl;
}

signed main(){
	int t=1;
	//cin>>t;
	while(t--) solve();
}

好的,我会分别介绍用数据结构完成的深度优先和广度优先搜索,以及求的关键路径。 1. 深度优先搜索(DFS): 深度优先搜索是一种遍历算法,它的基本思想是从一个起始节点开始,沿着一条边走到底,直到走到不能再走为止,然后退回到上一个节点,继续沿着其他的边走下去。这个过程不断重复,直到所有节点都被访问过。 深度优先搜索可以用递归或栈来实现。以下是使用栈实现的深度优先搜索代码: ```python def dfs(graph, start): visited = set() stack = [start] while stack: node = stack.pop() if node not in visited: visited.add(node) stack.extend(graph[node] - visited) return visited ``` 2. 广度优先搜索(BFS): 广度优先搜索是一种遍历算法,它的基本思想是从一个起始节点开始,先访问所有与该节点直接相邻的节点,然后依次访问它们的相邻节点,直到所有节点都被访问过。 广度优先搜索可以用队列来实现。以下是使用队列实现的广度优先搜索代码: ```python from collections import deque def bfs(graph, start): visited = set() queue = deque([start]) while queue: node = queue.popleft() if node not in visited: visited.add(node) queue.extend(graph[node] - visited) return visited ``` 3. 求的关键路径: 关键路径是指在一个有向无中,从起点到终点的所有路径中,最长的那条路径。求的关键路径可以使用拓扑排序和动态规划来实现。 以下是使用拓扑排序实现的求的关键路径代码: ```python def topsort(graph): in_degree = {node: 0 for node in graph} for node in graph: for neighbor in graph[node]: in_degree[neighbor] += 1 queue = [node for node in graph if in_degree[node] == 0] result = [] while queue: node = queue.pop(0) result.append(node) for neighbor in graph[node]: in_degree[neighbor] -= 1 if in_degree[neighbor] == 0: queue.append(neighbor) return result def critical_path(graph, duration): topo = topsort(graph) earliest = {node: 0 for node in topo} for node in topo: for neighbor in graph[node]: earliest[neighbor] = max(earliest[neighbor], earliest[node] + duration[node]) latest = {node: earliest[node] for node in topo} latest[topo[-1]] = earliest[topo[-1]] for node in reversed(topo): for neighbor in graph[node]: latest[node] = min(latest[node], latest[neighbor] - duration[node]) slack = {node: latest[node] - earliest[node] for node in topo} critical = {node for node in topo if slack[node] == 0} return earliest, latest, slack, critical ``` 其中,`graph`是一个字典,表示有向无,`duration`是一个字典,表示每个节点的持续时间。`topsort`函数使用拓扑排序算法来排序节点,`critical_path`函数使用动态规划算法来计算关键路径。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值