Leetcode 周赛第284场周赛总结

最新推荐文章于 2024-03-01 16:53:04 发布

spade_eddie

最新推荐文章于 2024-03-01 16:53:04 发布

阅读量2k

点赞数 2

CC 4.0 BY-SA版权

文章标签： leetcode 算法数据结构 java

本文链接：https://blog.youkuaiyun.com/weixin_51179742/article/details/123458370

本文总结了LeetCode第284场周赛的四道题目，包括找出数组中的所有K近邻下标、统计可以提取的工件、K次操作后最大化顶端元素和得到要求路径的最小带权子图。文章分析了解题思路，对比了个人解法与优秀解法，强调了熟悉内置函数、图算法和路径重合问题的重要性。

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

Leetcode 第284场周赛总结

给你一个整数 n ，它表示一个 带权有向 图的节点数，节点编号为 0 到 n - 1 。同时给你一个二维整数数组 edges ，其中 edges[i] = [fromi, toi, weighti] ，表示从 fromi 到 toi 有一条边权为 weighti 的有向边。最后，给你三个 互不相同 的整数 src1 ，src2 和 dest ，表示图中三个不同的点。请你从图中选出一个 边权和最小 的子图，使得从 src1 和 src2 出发，在这个子图中，都可以到达 dest 。如果这样的子图不存在，请返回 -1 。

子图中的点和边都应该属于原图的一部分。子图的边权和定义为它所包含的所有边的权值之和。

示例 1：

输入：n = 6, edges = [[0,2,2],[0,5,6],[1,0,3],[1,4,5],[2,1,1],[2,3,3],[2,3,4],[3,4,2],[4,5,1]], src1 = 0, src2 = 1, dest = 5
输出：9
解释：
上图为输入的图。
蓝色边为最优子图之一。
注意，子图 [[1,0,3],[0,5,6]] 也能得到最优解，但无法在满足所有限制的前提下，得到更优解。

示例 2：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v48CgnNX-1647150289703)(https://assets.leetcode.com/uploads/2022/02/17/example2-1drawio.png)]

输入：n = 3, edges = [[0,1,1],[2,1,1]], src1 = 0, src2 = 1, dest = 2
输出：-1
解释：
上图为输入的图。
可以看到，不存在从节点 1 到节点 2 的路径，所以不存在任何子图满足所有限制。

提示：

3 <= n <= 105
0 <= edges.length <= 105
edges[i].length == 3
0 <= fromi, toi, src1, src2, dest <= n - 1
fromi != toi
src1 ，src2 和 dest 两两不同。
1 <= weight[i] <= 105

/* 我以为很简单 直接Dijkstra算法就行了！ 结果我还是太天真了。
 	我的想法是：使用Dijkstra算法 1.找到src1 到 dest的最短距离  d1;
							  2.找到src2 到 dest的最短距离  d2;
							  3.如果有的话，找到src1 到 src2的最短距离 + d2 = d3;
							  4.         或者 src2 到 src1的最短距离 + d1 = d4;
							  返回 d1 + d2, d3, d4 的最大值；
	只过了72个测试用例，最后发现，需要考虑路径重合问题！！！！！
*/
// 大神解法： @arignote  （https://leetcode-cn.com/u/arignote/） （改变版，原版使用三目等，排版不好看）
// 没看太懂，尬住！
class Solution {
	public long minimumWeight(int n, int[][] edges, int src1, int src2, int dest) {
		ArrayList<long[]>[] list = new ArrayList[n], list2 = new ArrayList[n];
		for (int i = 0; i < n; i++) {
			list[i] = new ArrayList<>();
			list2[i] = new ArrayList<>();
		}
		for (int[] edge : edges) {
            // 每个索引，存储其子节点
			list[edge[0]].add(new long[] { edge[1], edge[2] });
            // 每个索引，存储其父节点
			list2[edge[1]].add(new long[] { edge[0], edge[2] });
		}
        // 
		Long s1[] = minimumWeight(src1, list);
        Long s2[] = minimumWeight(src2, list); 
        Long d[] = minimumWeight(dest, list2),
		Long min = Long.MAX_VALUE;
		for (int i = 0; i < n; i++) {
			if (s1[i] != null && s2[i] != null && d[i] != null) {
                min = Math.min(min, s1[i] + s2[i] + d[i]);
            }
		}
		return min < Long.MAX_VALUE ? min : -1;
	}

	private Long[] minimumWeight(int src, ArrayList<long[]>[] list) {
		Long[] dist = new Long[list.length], poll;
        // 使用优先级队列（小根堆）
		PriorityQueue<Long[]> queue = new PriorityQueue<>((a, b) -> Long.compare(a[0], b[0]));
		for (queue.offer(new Long[] { 0L, (long) src }); (poll = queue.poll()) != null;) {
			if (dist[poll[1].intValue()] == null) {
				dist[poll[1].intValue()] = poll[0];
				for (long[] edge : list[poll[1].intValue()]) {
					queue.offer(new Long[] { poll[0] + edge[1], edge[0] });
				}
			}
		}
		return dist;
	}
}