UVA 437 DAG最长路

本文探讨了在有限立方体集合中寻找最高堆叠的方法,通过动态规划算法实现高效的求解过程。
#include<cstring>
#include<stdio.h>
#include<iostream>
#include <algorithm>
using namespace std;
#define MAX 105
int n;
int block[MAX][3];
int d[MAX][3];
void get_(int *v, int id, int k)
{
	int cnt = 0;
	for (int i = 0;i != 3;++i)
	{
		if (i == k)
			continue;
		v[cnt++] = block[id][i];
	}
}
int dp(int id, int k)
{
	if (d[id][k] > 0)
		return d[id][k];
	d[id][k] = 0;
	int v1[2], v2[2];
	get_(v1, id, k);
	//计算编号id,高的编号为k的立方体作底上面最多可以放多高----d[id][k]
	for (int i = 0;i != n;++i)
		for (int j = 0;j != 3;++j)
		{
			get_(v2, i, j);
			if (v1[0] > v2[0] && v1[1] > v2[1])
				d[id][k] = max(d[id][k], dp(i, j));
		}
	d[id][k] += block[id][k];//加上自身高度
	return d[id][k];
}
int main()
{

	int casecnt = 0;
	while (cin >> n && n)
	{

		for (int i = 0;i != n;++i)
		{
			cin >> block[i][0] >> block[i][1] >> block[i][2];
			sort(block[i], block[i] + 3);
		}
		memset(d, 0, sizeof(d));
		int ans = 0;
		for (int i = 0;i != n;++i)
			for (int j = 0;j != 3;++j)
				ans = max(ans, dp(i, j));
		printf("Case %d: maximum height = %d\n", ++casecnt, ans);
	}
	return 0;
}

### DAG 最长路径的拓扑排序算法实现 在有向无环图 (Directed Acyclic Graph, DAG) 中,求解最长路径是一个经典问题。通过拓扑排序可以有效地解决这一问题。以下是基于拓扑排序的 DAG 最长路算法的具体实现。 #### 算法描述 1. **初始化**: 对于每个节点 \( v \),设置初始的距离值 `dist[v]` 为负无穷大 (\(-\infty\)),除了源节点外。对于源节点 \( s \),设 `dist[s] = 0`。 2. **拓扑排序**: 使用 Kahn 算法或其他方法获取图的拓扑顺序。 3. **动态规划更新**: 遍历拓扑序列中的每一个节点 \( u \),并对其所有的邻居节点 \( v \) 更新距离值: \[ \text{dist}[v] = \max(\text{dist}[v], \text{dist}[u] + w(u,v)) \] 其中 \( w(u,v) \) 是边 \( (u, v) \) 的权重[^1]。 #### Python 实现代码 以下是一个完整的 Python 实现: ```python from collections import defaultdict, deque def longest_path_dag(graph, weights, source): """ 计算DAG最长路径 :param graph: 字典表示的邻接表 {node: [neighbors]} :param weights: 边权字典 {(u, v): weight} :param source: 起始节点 :return: dist 和 parent 数组 """ # Step 1: 初始化 n = len(graph) indegree = {node: 0 for node in range(n)} # 每个节点的入度 dist = {node: float('-inf') for node in range(n)} parent = {node: None for node in range(n)} # 构建入度表 for u in graph: for v in graph[u]: indegree[v] += 1 # 设置起点距离为0 dist[source] = 0 # Step 2: 执行Kahn算法进行拓扑排序 queue = deque([node for node in indegree if indegree[node] == 0]) topo_order = [] while queue: u = queue.popleft() topo_order.append(u) for v in graph[u]: indegree[v] -= 1 if indegree[v] == 0: queue.append(v) # Step 3: 动态规划计算最长路径 for u in topo_order: for v in graph[u]: if dist[v] < dist[u] + weights[(u, v)]: dist[v] = dist[u] + weights[(u, v)] parent[v] = u return dist, parent # 测试用例 if __name__ == "__main__": # 定义图结构 graph = { 0: [1, 2], 1: [3], 2: [3], 3: [] } # 定义边权 weights = { (0, 1): 5, (0, 2): 3, (1, 3): 6, (2, 3): 7 } # 源节点 source = 0 # 获取结果 distances, parents = longest_path_dag(graph, weights, source) print("Distances:", distances) print("Parents:", parents) ``` #### 输出解释 上述代码会返回两个主要的结果: 1. **`distances`**: 表示从源节点到其他所有节点的最长路径长度。 2. **`parents`**: 存储前驱节点信息,用于重建具体的关键路径。 --- ### 关键概念解析 - **拓扑排序的重要性**: 在 DAG 中,拓扑排序确保了每条边的方向是从已处理的节点指向未处理的节点,从而避免循环依赖[^2]。 - **动态规划的核心思想**: 基于已经计算好的子问题最优解来逐步构建全局最优解。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值