Leetcode Day18 堆

Python中关于堆的操作

注意, python默认的是最小堆

什么时候想到用堆

A: 流!或者我们只关心k个元素

373 查找和最小的前k对数字

给定两个以 非递减顺序排列 的整数数组 nums1 和 nums2 , 以及一个整数 k 。

定义一对值 (u,v),其中第一个元素来自 nums1,第二个元素来自 nums2 。

请找到和最小的 k 个数对 (u1,v1), (u2,v2) ... (uk,vk) 。

输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3

输出: [1,2],[1,4],[1,6]

解释: 返回序列中的前 3 对数:

1,2\],\[1,4\],\[1,6\],\[7,2\],\[7,4\],\[11,2\],\[7,6\],\[11,4\],\[11,6

python 复制代码
class Solution:
    def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
        m = len(nums1)
        n = len(nums2)

        visited = set()
        ans = []
        h = []
        heappush(h, (nums1[0] + nums2[0], 0, 0))
        visited.add((0, 0))
        while len(ans) < k:
            num, i, j = heappop(h)
            ans.append([nums1[i], nums2[j]])
            if (i + 1, j) not in visited and i + 1 < m and j  < n:
                heappush(h, (nums1[i+1] + nums2[j], i+1, j))
                visited.add((i+1, j))

            if (i, j + 1) not in visited and i < m and j + 1 < n:
                heappush(h, (nums1[i] + nums2[j + 1], i, j + 1))
                visited.add((i, j+1))
        return ans

后面的优化就是怎么样能不用hashset

换个角度,如果要把 (i,j) 入堆,那么之前出堆的下标对是什么?

根据上面的讨论,出堆的下标对只能是 (i−1,j) 和 (i,j−1)。

只要保证 (i−1,j) 和 (i,j−1) 的其中一个会将 (i,j) 入堆,而另一个什么也不做,就不会出现重复了!

不妨规定 (i,j−1) 出堆时,将 (i,j) 入堆;而 (i−1,j) 出堆时只计入答案,其它什么也不做。

换句话说,在 (i,j) 出堆时,只需将 (i,j+1) 入堆,无需将 (i+1,j) 入堆。

但若按照该规则,初始仅把 (0,0) 入堆的话,只会得到 (0,1),(0,2),⋯ 这些下标对。

所以初始不仅要把 (0,0) 入堆,(1,0),(2,0),⋯ 这些都要入堆。

python 复制代码
class Solution:
    def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
        ans = []
        h = [(nums1[i] + nums2[0], i, 0) for i in range(min(len(nums1), k))]
        while len(ans) < k:
            _, i, j = heappop(h)
            ans.append([nums1[i], nums2[j]])
            if j + 1 < len(nums2):
                heappush(h, (nums1[i] + nums2[j + 1], i, j + 1))
        return ans

347. 前 K 个高频元素

给你一个整数数组 nums 和一个整数 k ,请你返回其中出现频率前 k 高的元素。你可以按任意顺序返回答案。

输入: nums = [1,1,1,2,2,3], k = 2

输出: [1,2]

O ( n l o g n ) O(nlogn) O(nlogn)的算法显然很简单, 但有没有方法可以降一下这个呢? 事实上, 我们只关心前k个, 我们变能把复杂度降为 O ( n l o g k ) O(nlogk) O(nlogk), 那么能保持这个前k个元素的结构自然就是堆了.

python 复制代码
class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        frequencyMap = {}
        for num in nums:
            if num in frequencyMap:
                frequencyMap[num] += 1
            else:
                frequencyMap[num] = 1

        minHeap = []
        for item, freq in frequencyMap.items():
            print(minHeap)
            if len(minHeap) < k:
                heappush(minHeap, (freq, item))
            else:
                top_node = minHeap[0]
                if freq > top_node[0]:
                    heappop(minHeap)
                    heappush(minHeap, (freq, item))
        return [num for freq, num in minHeap]

23 合并k个升序链表

python 复制代码
ListNode.__lt__ = lambda a, b: a.val < b.val  # 让堆可以比较节点大小

class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        cur = dummy = ListNode()  # 哨兵节点,作为合并后链表头节点的前一个节点
        h = []
        for head in lists:
            if head:
                h.append(head)
        heapify(h)  # 堆化
        while h:  # 循环直到堆为空
            node = heappop(h)  # 剩余节点中的最小节点
            if node.next:  # 下一个节点不为空
                heappush(h, node.next)  # 下一个节点有可能是最小节点,入堆
            cur.next = node  # 合并到新链表中
            cur = cur.next  # 准备合并下一个节点
        return dummy.next  # 哨兵节点的下一个节点就是新链表的头节点
相关推荐
YuTaoShao3 分钟前
【LeetCode 热题 100】994. 腐烂的橘子——BFS
java·linux·算法·leetcode·宽度优先
Wendy14418 小时前
【线性回归(最小二乘法MSE)】——机器学习
算法·机器学习·线性回归
拾光拾趣录8 小时前
括号生成算法
前端·算法
渣呵9 小时前
求不重叠区间总和最大值
算法
浮生带你学Java9 小时前
2025Java面试题及答案整理( 2025年 7 月最新版,持续更新)
java·开发语言·数据库·面试·职场和发展
拾光拾趣录9 小时前
链表合并:双指针与递归
前端·javascript·算法
好易学·数据结构9 小时前
可视化图解算法56:岛屿数量
数据结构·算法·leetcode·力扣·回溯·牛客网
香蕉可乐荷包蛋10 小时前
AI算法之图像识别与分类
人工智能·学习·算法
chuxinweihui10 小时前
stack,queue,priority_queue的模拟实现及常用接口
算法
tomato0910 小时前
河南萌新联赛2025第(一)场:河南工业大学(补题)
c++·算法