Leetcode(4)——堆和优先队列

最新推荐文章于 2023-03-25 13:15:00 发布
最新推荐文章于 2023-03-25 13:15:00 发布
阅读量218 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode golang python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengyuhao1995/article/details/106004855
版权

格式：

题号+题名+简单思路+code



※T743: 网络延迟时间

  • 暴力遍历每一条可以被放松的路径
  • O ( N N + E l o g ( E ) ) O(N^N+Elog(E)) O(NN+Elog(E)) 时间复杂度
var MAXINT int = 1<<31-1

type Edge struct {
    to int
    time int
}

func networkDelayTime(times [][]int, N int, K int) int {
    distances:=map[int]int{}
    graph:=map[int][]Edge{}
    for i:=1;i<=N;i++ {
        distances[i]=MAXINT
        graph[i]=[]Edge{}
    }
    distances[K]=0
    for i:=0;i<len(times);i++ {
        ti:=times[i]
        graph[ti[0]]=append(graph[ti[0]],Edge{ti[1],ti[2]})
    }
    dfs(graph,distances,K)
    totalTime:=0
    for _,v:=range distances {
        if v==MAXINT {
            return -1
        }
        if v>totalTime {
            totalTime=v
        }
    }
    return totalTime
}

func dfs(graph map[int][]Edge, distances map[int]int,K int) {
    tmp:=graph[K]
    time:=distances[K]
    for i:=0;i<len(tmp);i++ {
        if time+tmp[i].time<distances[tmp[i].to] {
            distances[tmp[i].to]=time+tmp[i].time
            dfs(graph,distances,tmp[i].to)
        }
    }
}
  • Dijsktra算法
  • O(NlogN)时间复杂度
  1. 索引优先队列实现(《算法四》)
import "container/heap"

type Edge struct {
    to int
    time int
    index int
}

type TimeHeap []*Edge

func (t TimeHeap) Len() int {
    return len(t)
}

func (t TimeHeap) Less(i int, j int) bool {
    return t[i].time-t[j].time <0
}

func (t TimeHeap) Swap(i int, j int) {
    t[i],t[j]=t[j],t[i]
    t[i].index,t[j].index=i,j
}

func (t *TimeHeap) Push(i interface{}) {
    tmp:=i.(*Edge)
    tmp.index=t.Len()
    *t=append(*t,tmp)
}

func (t *TimeHeap) Pop() interface{} {
    x:=(*t)[len(*t)-1]
    *t=(*t)[:len(*t)-1]
    x.index=-1
    return x
}

func (t *TimeHeap) Update(e *Edge,time int) {
    e.time=time
    heap.Fix(t,e.index)
}



var MAXINT int=int(^uint(0) >> 1)

func networkDelayTime(times [][]int, N int, K int) int {
    graph:=make(map[int][]Edge,N)
    minL:=make(map[int]int,N)
    for i:=1;i<=N;i++ {
        graph[i]=[]Edge{}
        minL[i]=MAXINT
    }
    for i:=0;i<len(times);i++ {
        ti:=times[i]
        graph[ti[0]]=append(graph[ti[0]],Edge{ti[1],ti[2],-1})
    }
    totalTime:=0
    memo:=make(map[int]*Edge,0)
    start:=&Edge{K,0,-1}
    memo[K]=start
    minL[K]=0
    timeheap:=&TimeHeap{start}
    for timeheap.Len()>0 {
        edge:=heap.Pop(timeheap).(*Edge)
        delete(memo,edge.to)
        tmp:=graph[edge.to]
        for i:=0;i<len(tmp);i++ {
            n:=tmp[i].to
            d:=tmp[i].time
            if edge.time+d<minL[n] {
                minL[n]=edge.time+d
                if point,ok:=memo[n];ok {
                    timeheap.Update(point,minL[n])
                } else {
                    start=&Edge{n,minL[n],-1}
                    heap.Push(timeheap,start)
                    memo[n]=start
                }
            }
        }
    }
    for i:=range minL {
        if minL[i]==MAXINT {
            return -1
        }
        if minL[i]>totalTime {
            totalTime=minL[i]
        }
    }

    return totalTime
    
}
  1. 不进行Update，仅Push和去重
import "container/heap"

type Edge struct {
    to int
    time int
}

type TimeHeap []Edge

func (t TimeHeap) Len() int {
    return len(t)
}

func (t TimeHeap) Less(i int, j int) bool {
    return t[i].time-t[j].time <0
}

func (t TimeHeap) Swap(i int, j int) {
    t[i],t[j]=t[j],t[i]
}

func (t *TimeHeap) Push(i interface{}) {
    *t=append(*t,i.(Edge))
}

func (t *TimeHeap) Pop() interface{} {
    x:=(*t)[len(*t)-1]
    *t=(*t)[:len(*t)-1]
    return x
}


var MAXINT int=int(^uint(0) >> 1)

func networkDelayTime(times [][]int, N int, K int) int {
    graph:=make(map[int][]Edge,N)
    minL:=make(map[int]int,N)
    for i:=1;i<=N;i++ {
        graph[i]=[]Edge{}
        minL[i]=MAXINT
    }
    for i:=0;i<len(times);i++ {
        ti:=times[i]
        graph[ti[0]]=append(graph[ti[0]],Edge{ti[1],ti[2]})
    }
    totalTime:=0
    memo:=make(map[int]interface{},0)
    timeheap:=&TimeHeap{Edge{K,0}}
    for timeheap.Len()>0 {
        edge:=heap.Pop(timeheap).(Edge)
        if _,ok:=memo[edge.to];ok {
            continue
        }
        memo[edge.to]=nil
        minL[edge.to]=edge.time
        tmp:=graph[edge.to]
        for i:=0;i<len(tmp);i++ {
            n:=tmp[i].to
            d:=tmp[i].time
            if _,ok:=memo[n];!ok && edge.time+d<minL[n] {
                heap.Push(timeheap,Edge{n,edge.time+d})
            }
        }
    }
    for i:=range minL {
        if minL[i]==MAXINT {
            return -1
        }
        if minL[i]>totalTime {
            totalTime=minL[i]
        }
    }

    return totalTime
    
}




T264: 丑数Ⅱ

  • 练习预计算
  • golang中使用全局变量
  • 升序排列→堆排序
import (
    "container/heap"
)

var pre []int=buildList()
type Stack []int

func (s Stack) Len() int {
    return len(s)
}

func (s Stack) Less(i int, j int) bool {
    return s[i]-s[j]<0
}

func (s Stack) Swap(i int,j int) {
    s[i],s[j]=s[j],s[i]
}

func (s *Stack) Push(i interface{}) {
    tmp:=*s
    *s=append(tmp,i.(int))
}

func (s *Stack) Pop() interface{} {
    tmp:=*s
    x:=tmp[len(tmp)-1]
    *s=tmp[:len(tmp)-1]
    return x
}

func buildList() []int {
    result:=make(map[int]interface{})
    stack:=&Stack{1}
    p_result:=make([]int,1690)
    for index:=0;index<1690;index++ {
        i:=heap.Pop(stack).(int)
        if _,ok:=result[i];ok {
            index--
            continue
        }
        result[i]=nil
        p_result[index]=i
        heap.Push(stack,i*2)
        heap.Push(stack,i*3)
        heap.Push(stack,i*5)
    }
    return p_result
}

func nthUglyNumber(n int) int {
    return pre[n-1]
}
  • python中使用静态变量
from heapq import heappush,heappop

def buildList() -> List:
    result=[0 for i in range(1690)]
    memo=set()
    heap=[1]
    index=0
    while index<1690:
        i=heappop(heap)
        if i in memo:
            continue
        memo.add(i)
        result[index]=i
        index+=1
        heappush(heap,i*2)
        heappush(heap,i*3)
        heappush(heap,i*5)
    return result




class Solution:
    pre=buildList()
    def nthUglyNumber(self, n: int) -> int:
        return self.pre[n-1]




※T215: 数组中的第K大元素

  • 快速选择算法
  • 适用于有重复数组
  • 最好时间复杂度O(N)
func findKthLargest(nums []int, k int) int {
    return assist(nums,0,len(nums)-1,len(nums)+1-k)
}

func assist(nums []int,start int,end int,k int) int {
    ans:=0
    ref:=nums[start]
    i1:=start
    i2:=end
    for end>start {
        for ;end>start;end-- {
            if nums[end]<ref {
                nums[start]=nums[end]
                break
            }
        }
        for ;end>start;start++ {
            if nums[start]>ref {
                nums[end]=nums[start]
                break
            }
        }
    }
    if k>start+1 {
        ans=assist(nums,start+1,i2,k)
    } else if k<start+1 {
        ans=assist(nums,i1,start-1,k)
    } else {
        ans=ref
    }
    return ans
    
}
  • 最小堆
  • O(NlogK)
import "container/heap"

type Stack []int

func (s Stack) Len() int {
    return len(s)
}

func (s Stack) Less(i int, j int) bool {
    return s[i]-s[j]<0
}

func (s Stack) Swap(i int,j int) {
    s[i],s[j]=s[j],s[i]
}

func (s *Stack) Push(i interface{}) {
    *s=append(*s,i.(int))
}

func (s *Stack) Pop() interface{} {
    tmp:=*s
    x:=tmp[len(tmp)-1]
    *s=tmp[:len(tmp)-1]
    return x
}

func findKthLargest(nums []int, k int) int {
    if len(nums)==0 {
        return -1
    }
    stack:=&Stack{}
    for i:=0;i<len(nums);i++ {
        heap.Push(stack,nums[i])
        if stack.Len()>k {
            heap.Pop(stack)
        }
    }
    return heap.Pop(stack).(int)
}




剑指40: 最小的k个数

  • 快速选择，找到第k-1个位置后，取前k个数即可
class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        if k<=0:
            return []
        return self.assist(arr, k-1, 0, len(arr)-1)
    def assist(self, arr, k, lo, hi):
        start=lo
        end=hi
        tmp=arr[lo]
        while lo<hi:
            while lo<hi and arr[hi]>=tmp:
                hi-=1
            arr[lo]=arr[hi]
            while lo<hi and arr[lo]<=tmp:
                lo+=1
            arr[hi]=arr[lo]
        arr[lo]=tmp    # 易错
        if lo<k:
            return self.assist(arr, k, lo+1, end)
        elif lo>k:
            return self.assist(arr, k, start, lo-1)
        else:
            return arr[:k+1]




T378: 有序矩阵中第K小元素

  • 最大堆
  • O ( N 2 l o g K ) O(N^2logK) O(N2logK)
from heapq import heappop,heappush

class Solution:
    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
        if k<1 or k>len(matrix)*len(matrix):
            return -1
        heap=[]
        for i in matrix:
            for j in i:
                heappush(heap,-j)
                if len(heap)>k:
                    heappop(heap)
        return -heappop(heap)
  • 值域二分查找；类似问题(快速选择算法和BST找第K小元素)
  • 针对有序矩阵结构
  • 取ceil
  • O(NlogH)
from math import ceil
class Solution:
    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
        lo=matrix[0][0]
        hi=matrix[-1][-1]
        while lo<hi:
            mid=ceil((hi-lo)/2)+lo
            rank=self.getRank(matrix,mid)
            if k<rank+1:
                hi=mid-1
            else:
                lo=mid
        return lo
    def getRank(self,matrix:List[List[int]],value:int) -> int:
        count=0
        i=len(matrix)-1
        j=0
        while i>=0 and j<=len(matrix)-1:
            if matrix[i][j]>=value:
                i-=1
            else:
                count+=i+1
                j+=1
        return count




T347: 前K个高频元素

  • 最小堆
  • O(NlogK)
import "container/heap"

type item struct {
    val int
    count int
}

type minHeap []item 

func (m minHeap) Len() int {
    return len(m)
}

func (m *minHeap) Swap(i int,j int) {
    (*m)[i],(*m)[j]=(*m)[j],(*m)[i]
}

func (m minHeap) Less(i int,j int) bool {
    return m[i].count-m[j].count<0
}

func (m *minHeap) Push(i interface{}) {
    *m=append(*m,i.(item))
}

func (m *minHeap) Pop() interface{} {
    i:=(*m)[len(*m)-1]
    *m=(*m)[:len(*m)-1]
    return i
}

func topKFrequent(nums []int, k int) []int {
    if len(nums)==0 {
        return nil
    }
    memo:=map[int]int{}
    for _,i := range nums {
        if _,ok:=memo[i];ok {
            memo[i]++
        } else {
            memo[i]=1
        }
    }
    tmp:=&minHeap{}
    for key,value := range memo {
        heap.Push(tmp,item{key,value})
        if tmp.Len() > k {
            heap.Pop(tmp)
        }
        
    }
    ans:=[]int{}
    for _,v := range *tmp {
        ans=append(ans,v.val)
    }
    return ans

}




※T407: 接雨水Ⅱ

  • 类似T42: 接雨水解法2，该方法通过计算最外端中较小值来更新答案，同时更新新的最外端高度值
  • 该题与解法2基本思路是一样的，不过在二维上需要根据最外圈的最小值来更新答案，即木桶原理
  • 因此首先将最外圈作为边界存入最小堆，同时用数组记录已遍历过的位置；然后弹出最小高度，比较其四个方向中合理且未遍历的位置，如果能接水则更新答案，最后将二者较高的高度加入堆中(即更新最外圈)，并记录该位置已遍历
import "container/heap"

type Item struct {
    i int
    j int
    height int
}

type Item_pri []Item

func (this Item_pri) Len() int {
    return len(this)
}

func (this Item_pri) Less(idx_i int, idx_j int) bool {
    return this[idx_i].height-this[idx_j].height<0
}

func (this Item_pri) Swap(idx_i int, idx_j int) {
    this[idx_i],this[idx_j]=this[idx_j],this[idx_i]
}

func (this *Item_pri) Push(x interface{}) {
    *this=append(*this,x.(Item))
}

func (this *Item_pri) Pop() interface{} {
    x:=(*this)[len(*this)-1]
    *this=(*this)[:len(*this)-1]
    return x
}

func trapRainWater(heightMap [][]int) int {
    m:=len(heightMap)
    if m==0 {
        return 0
    }
    n:=len(heightMap[0])
    minHeap:=&Item_pri{}
    directs:=[4][2]int{{0,1},{0,-1},{1,0},{-1,0}}
    ans:=0
    visited:=make([][]bool,m)
    for i:=0;i<m;i++ {
        visited[i]=make([]bool,n)
    }
    for i:=0;i<m;i++ {
        for j:=0;j<n;j++ {
            if i==0 || j==0 || i==m-1 || j==n-1 {
                heap.Push(minHeap,Item{i,j,heightMap[i][j]})
                visited[i][j]=true
            }
        }
    }
    for minHeap.Len() >0 {
        minX:=heap.Pop(minHeap).(Item)
        for k:=0;k<4;k++ {
            idx_i:=minX.i+directs[k][0]
            idx_j:=minX.j+directs[k][1]
            if idx_i>0 && idx_i<m && idx_j>0 && idx_j<n && !visited[idx_i][idx_j] {
                if heightMap[idx_i][idx_j]<minX.height {
                    ans+=minX.height-heightMap[idx_i][idx_j]
                    heap.Push(minHeap,Item{idx_i,idx_j,minX.height})
                } else {
                    heap.Push(minHeap,Item{idx_i,idx_j,heightMap[idx_i][idx_j]})
                }
                visited[idx_i][idx_j]=true
            }
        }
    }
    return ans
}
某热心知名群众
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题笔记——994. 腐烂的橘子
12-21
难度：简单 ...那么在广度优先搜索的时候，我们将这些腐烂橘子都放进队列里进行广度优先搜索即可，最后每个新鲜橘子被腐烂的最短时间其实是以这个超级源点的腐烂橘子为起点的广度优先搜索得到的结果
leetcode 4 golang Median of Two Sorted Arrays
国苏
05-13 293
两个有序数组的中卫数，可以转换为求第k小的数 奇数是找到第k小的就可以了 偶数是找到k 和 k + 1 在取平均值func findMedianSortedArrays(nums1 []int, nums2 []int) float64 { n1 := nums1 n2 := nums2 pa := 0 //第一个数组的指针 pb := 0 //第二个数组的指针
Leetcode 优先队列详解
若明天不见
03-25 703
本文为优先队列详解及相关题型的解答思路。在优先队列中，元素被赋予优先级，当访问队列元素时，具有最高优先级的元素最先删除。根据数组元素从大到小进行排序本文。解题思路通常为优先队列/最大堆，依次入队排序后取队头的第K大的元素。
LeetCode基础-排序-二叉堆排序（优先队列）
gnimgnot
11-01 1371
有些情况下要求不一定要求数组全部有序，或者说不一定要一定性全部有序。 有些情况下先收集一些元素，找到这些元素中的最大值，然后重复这个步骤。 比如，电脑或手机上运行的多个应用程序，可以给每个程序分配一个优先队列，并总是处理下一个优先级最高的那个应用程序。这就需要优先队列了，它支持这两种操作： 删除最大元素 插入元素 优先队列与队列（删除最老元素）和栈（删除最新元素）类似，但更高效。二叉堆数据结构能
LeetCode:二叉最大堆的实现，优先队列
Jiangtagong的博客
01-14 223
手撕二叉最大堆 /*二叉最大堆的实现*/ #include <iostream> #include <vector> using namespace std; class greaterheap{ public: void make_heap(vector<int>& a){ for(int i=a.size()-1;i>=0;i--){ heap_down(a,i);/*从后向前调用heap_dow.
LeetCode题解(Golang实现)--Longest Palindromic Substring
EvansChang
09-18 1227
题目Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.Example:Input: "babad"Output: "bab"Note: "aba" is also a valid answer. Example:Input
我的LeetCode和剑指offer刷题源码——Java版.zip
11-06
标题 "我的LeetCode和剑指offer刷题源码——Java版.zip" 提示这是一个包含Java编程语言实现的解题代码库，主要针对两个知名的在线编程挑战平台：LeetCode和剑指Offer（也称为《程序员面试金典》）。LeetCode是一个...
Java实现 LeetCode 632 最小区间（又是先序队列，官方给的是堆）
12-21
在这个问题中，我们被要求解决LeetCode上的第632题——最小区间。这个问题涉及到在k个升序排列的整数数组中找到一个最小区间，使得每个数组至少有一个元素在这个区间内。区间 [a, b] 被认为比 [c, d] 更小，如果 b-a...
leetcode答案-leetcode:算法和数据结构
06-30
《LeetCode答案——算法与数据结构深度解析》 LeetCode是一个全球知名的在线编程挑战平台，致力于帮助程序员提升算法技能和解决实际问题的能力。这个压缩包文件"leetcode-master"很可能包含了某位开发者在LeetCode...
leetcode-rust：锈中的leetcode
02-02
例如，我们可以使用二分查找法解决搜索问题，利用堆来实现优先队列，或者运用哈希表进行动态规划状态的存储。在Rust中，我们还可以利用 trait 和 impl 关键字为自定义数据结构实现通用算法，增加代码复用性。 在...
leetcode-solutions:LeetCode解决方案
03-26
《LeetCode解决方案——深入探索JavaScript编程技巧》 LeetCode是一个广受欢迎的在线平台，它提供了大量的编程题目，旨在提升程序员的算法技能和问题解决能力。本项目“leetcode-solutions”汇集了作者Ahmed Engu在...
python-leetcode面试题解之第373题查找和最小的K对数字.zip
最新发布
06-26
此外，为了提高效率，可以使用优先队列（堆）等数据结构，这能确保在O(K log K)的时间复杂度内完成搜索。 总之，这个压缩包提供的资源可能包含了对LeetCode第373题的详细解题思路、Python代码实现以及可能的优化...
php-leetcode题解之滑动谜题.zip
06-09
在编程世界中，LeetCode是一个非常知名的在线平台，它提供了丰富的算法题目供程序员们练习和提升。本资料主要关注的是使用PHP解决LeetCode中的一类问题——滑动谜题。滑动谜题通常涉及到二维数组的操作、动态规划...
算法和数据结构练习（Leetcode）.zip
01-05
《算法和数据结构练习——基于LeetCode平台》 在计算机科学与信息技术领域，算法和数据结构是基础且至关重要的组成部分。LeetCode是一个在线平台，它提供了丰富的编程挑战，特别是针对算法和数据结构的实践题目，...
算法和数据结构——左程云.zip
06-17
在本资源包中，可能会涵盖排序算法（如冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等）、搜索算法（如二分查找、广度优先搜索、深度优先搜索）以及图算法（如Dijkstra算法、Floyd算法、最小生成树...
LeetCode Golang 答案
一元硬币
05-28 2975
Leetcode用golang实现的答案。全都会push到github上。 已经有的题目和答案链接如下： Question Solutioin 1.two sum [1.two sum.py](https://github.com/NachtZ/leetcode/blob/master/1.two sum.py) Add Two Numbers [2. Add Two Num
leetcode golang刷题总结-队列
——
02-24 186
滑动窗口 func maxSlidingWindow(nums []int, k int) []int { len:=len(nums) if len<=0||k<=0||k>len{ return nil } var maxnums []int max:=-1 for i:=0;i<=len-k;i++{ low:=i high:=i+k-1 if max==-1||ma
leetcode算法题—golang—两个排序数组的中位数（题4）
墨怀旧
11-11 436
题目：两个排序数组的中位数 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。 请找出这两个有序数组的中位数。要求算法的时间复杂度为 O(log (m+n)) 。 你可以假设 nums1 和 nums2 不同时为空。 示例 1: nums1 = [1, 3] nums2 = [2] 中位数是 2.0 示例 2: nums1 = [1, 2] nums2 =...
第8章 优先队列和堆（Leetcode原题）
入凡尘狼性不足
06-15 313
第八章 优先队列和堆 8-1 什么是优先队列 8-2 堆的基础表示 8-3 向堆中添加元素和Sift Up 8-4 从堆中取出元素和Sift Down 8-5 Heapify 和Replace 8-6 基于堆的优先队列 8-7 Leetcode上优先队列相关问题 8-8 Java中的PriorityQueue 8-9 和堆相关的更多话题和广义队列 8-1 什么是优先队列 我们在之前的两章向大家详细介绍了二分搜索树这种数据结构，同时我们使用二分搜索树实现了集合和映射这两个相对来讲更加高层的数据结构。树这种
苏大Python复试上机：LeetCode高频题集——英语字母顺序挑战
4. 方阵中战斗力最弱的K行（1337题）：数组和矩阵操作，需要找到一个方阵中战斗力最弱的K行，这可能需要动态规划或优先队列等数据结构。 5. 独特的电子邮件地址（929题）：字符串匹配问题，旨在检查电子邮件地址的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值