力扣面试经典150 —— 11-15题

  • 力扣面试经典150题
  • 在 VScode 中安装 LeetCode 插件即可使用 VScode 刷题,安装 Debug LeetCode 插件可以免费 debug
  • 本文使用 python 语言解题,文中 “数组” 通常指 python 列表;文中 “指针” 通常指 python 列表索引

文章目录

  • 11. [中等] H指数
    • 11.1 解法1:暴力法
    • 11.2 解法2:计数排序
    • 11.3 解法3:排序
  • 12. [中等] O(1) 时间插入、删除和获取随机元素
    • 12.1 解法1:哈希表+变长数组
  • 13. [中等] 除自身以外的数组的乘积
    • 13.1 解法1:左右乘积列表
    • 13.2 解法2:左右乘积列表
  • 14. [中等] 加油站
    • 14.1 解法1:一次遍历
  • 15. [困难] 分发糖果
    • 15.1 解法1:两次遍历

11. [中等] H指数

  • 题目链接
  • 标签:数组、计数排序、排序
    在这里插入图片描述

11.1 解法1:暴力法

  • 根据题目可知,h 指数不能超过论文发表总数,也不能超过最高引用此次,其最大值为 min(max(citations), len(citations))。从该最大可能取值开始反向遍历所有可能取值 i,统计引用次数 >=i 的论文数量 paper_cnt,直到找到满足 h 指数的定义(即 paper_cnt>=i)的取值为止。这是一种带剪枝的暴力搜索方法
    class Solution:def hIndex(self, citations: List[int]) -> int:# 根据定义,h 指数的理论最大值max_h = min(max(citations), len(citations))# 从 max_h 开始反向遍历考察所有 h 指数的可能取值 i for i in range(max_h, -1, -1):# 统计引用次数 >= i 的论文数量paper_cnt = 0for cite in citations:if cite >= i:paper_cnt += 1# 满足 h 指数定义则返回if paper_cnt >= i:return ireturn 0
    
  • 时间复杂度 O ( n 2 ) O(n^2) O(n2),空间复杂度 O ( 1 ) O(1) O(1)

11.2 解法2:计数排序

  • 以上暴力法中,对于每一个候选的 h 指数取值都做了一次遍历计数,因此时间复杂度高。一种优化方式是,先用过一次遍历完成所有计数操作,再通过另一次和暴力法相同的反向遍历确定 h 指数的值。具体而言,第一次遍历中我们用 defaultdict 统计引用量为 h 指数各可能取值i 的论文数量,之后在反向遍历时通过求和得到引用量 >=i 的论文数量
  • 这种方法通过引入 O ( n ) O(n) O(n) 的额外存储空间,将时间复杂度从 O ( n 2 ) O(n^2) O(n2) 降低到 O ( n ) O(n) O(n)
    class Solution:    def hIndex(self, citations: List[int]) -> int:# 根据定义,h 指数的理论最大值max_h = min(max(citations), len(citations))# 用 counter 统计引用量 >= 不同 cite 值的论文数量from collections import defaultdictcounter = defaultdict(int)for cite in citations:cite = max_h if cite > max_h else citecounter[cite] += 1# 从 max_h 开始反向遍历考察所有 h 指数的可能取值 i tot = 0     for i in range(max_h, -1, -1):tot += counter[i]   # 引用量不少于 i 次的论文总数if tot >= i:        # 满足 h 指数定义则返回return ireturn 0
    
  • 时间复杂度 O ( n ) O(n) O(n),空间复杂度 O ( n ) O(n) O(n)

11.3 解法3:排序

  • 先初始化 h=0,然后把引用次数 citations 排序并大到小遍历。如果当前 h 指数为 h 并且在遍历过程中找到当前值 citations[i]>h,则说明我们找到了一篇被引用了至少 h+1 次的论文,所以 h+=1。继续遍历直到 h 无法继续增大后返回即可
    class Solution:def hIndex(self, citations: List[int]) -> int:sorted_citation = sorted(citations, reverse = True)h = 0; i = 0; n = len(citations)while i < n and sorted_citation[i] > h:h += 1i += 1return h
    
  • 时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn),空间复杂度 O ( l o g n ) O(logn) O(logn)(这两个都是排序算法的复杂度)

12. [中等] O(1) 时间插入、删除和获取随机元素

  • 题目链接
  • 标签:设计、数组、哈希表、数学
    在这里插入图片描述

12.1 解法1:哈希表+变长数组

  • 要求实现插入删除获取随机元素操作的平均时间复杂度为 O ( 1 ) O(1) O(1)
    1. 变长数组:可以在 O ( 1 ) O(1) O(1) 的时间内完成获取随机元素操作。但是由于需要 O ( n ) O(n) O(n) 时间判断元素是否存在,因此无法满足插入和删除的时间复杂度要求
    2. 哈希表:哈希表的核心思想,是通过函数函数把元素映射到存储位置索引,这样就能在 O ( 1 ) O(1) O(1) 的时间内判断元素是否存在,或找到元素存储位置进行插入或删除。但哈希表无法在 O ( 1 ) O(1) O(1) 时间内获取当前全体元素,因此无法满足随机取元素的时间复杂度要求
  • 通过结合变长数组和哈希表,可以实现题目要求
    class RandomizedSet:def __init__(self):from collections import defaultdictimport randomself.item = []  # 在此存储元素self.idx = {}   # 哈希表,将元素映射到其在 self.item 中的索引位置def insert(self, val: int) -> bool:if val in self.idx:return Falseself.item.append(val)self.idx[val] = len(self.item) - 1return Truedef remove(self, val: int) -> bool:if not val in self.idx:return Falseidx_val = self.idx[val]         item_last = self.item[-1]       self.item[idx_val] = item_last  # self.item 中,用 item_last 替换目标元素self.idx[item_last] = idx_val   # self.idx 哈希表中,更新 item_last 对应的索引位置self.item.pop()                 # 弹出已经移动到 idx_val 处的 item_lastdel self.idx[val]               # 删除目标元素在哈希表中的索引return Truedef getRandom(self) -> int:return random.choice(self.item)# Your RandomizedSet object will be instantiated and called as such:
    # obj = RandomizedSet()
    # param_1 = obj.insert(val)
    # param_2 = obj.remove(val)
    # param_3 = obj.getRandom()
    # @lc code=end
    

13. [中等] 除自身以外的数组的乘积

  • 题目链接
  • 标签:数组、前缀和
    在这里插入图片描述

13.1 解法1:左右乘积列表

  • 用双指针同时从左右开始遍历列表,将左侧所有数字的乘积(前缀积)和右侧所有数字的乘积(后缀积)存储到两个辅助列表中。最后将两个辅助列表对应位置相乘得到结果
    class Solution:def productExceptSelf(self, nums: List[int]) -> List[int]:# pre_prods 存储每个索引位置所有前驱元素乘积# post_prods 存储每个索引位置所有后继元素乘积pre_prod, post_prod = 1, 1pre_prods, post_prods = [], []left, right = 0, -1for i in range(len(nums)):pre_prods.append(pre_prod)post_prods.append(post_prod)pre_prod *= nums[left]post_prod *= nums[right]left += 1right -= 1post_prods.reverse() # 输出中每个索引位置,取 pre_prods 和 post_prods 对应位置元素相乘即可res = []for i in range(len(nums)):res.append(pre_prods[i] * post_prods[i])return res
    
  • 时间复杂度 O ( n ) O(n) O(n),空间复杂度 O ( n ) O(n) O(n)

13.2 解法2:左右乘积列表

  • 以上方法需要构造存储前缀积和后缀积的两个辅助列表。为了减少空间复杂度,可以先构造前缀积列表,然后在计算后续元素乘积时直接将其乘到前缀积列表中并作为输出。这样可以把空间复杂度降低到 O ( 1 ) O(1) O(1)(不考虑输出数组)
    class Solution:def productExceptSelf(self, nums: List[int]) -> List[int]:# pre_prods 存储每个索引位置所有前驱元素乘积pre_prod = 1res = []for num in nums:res.append(pre_prod)pre_prod *= num# 再把后续元素乘积直接乘到 res 的对应位置上,实现 O(1) 的空间复杂度post_prod = 1for i in range(len(nums)-1, -1, -1):res[i] *= post_prodpost_prod *= nums[i]return res
    
  • 时间复杂度 O ( n ) O(n) O(n),空间复杂度 O ( 1 ) O(1) O(1)

14. [中等] 加油站

  • 题目链接
  • 标签:贪心、数组
    在这里插入图片描述

14.1 解法1:一次遍历

  • 最直接的思想是依次把每一个加油站作为起点进行考察,直到找到能够绕行一周的加油站为止,但是这种暴力解法时间复杂度高。可以通过减小被检查的加油站数目来降低时间复杂度。
  • 注意到这样一个事实:如果从 x 加油站出发最多只能到达 z 加油站,那么从 x 和 z 之间的 y 加油站出发一定无法到达超过 z 的位置。这是因为从 x 出发到达 y 时可能车里还有剩余燃油,直接从 y 出发不可能走得更远
  • 我们可以从第 0 个加油站开始判断能否环绕一周;如果不能,就从第一个无法到达的加油站开始继续检查。
    class Solution:def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:def _available_cnt(idx):# 计算从 idx 开始可以连续到达的加油站数量cnt, gas_left = 0, 0for i in range(n):gas_left += delta[(idx + i) % n] if gas_left < 0:return cntcnt += 1return cnt# 从各个加油站出发到下一个加油站导致的油量变化delta = [g - c for g, c in zip(gas, cost)]  # 检查从各个加油站出发能否环绕一周;不能则从第一个无法到达的加油站开始继续检查n, idx = len(gas), 0while idx < n:cnt = _available_cnt(idx)# 找到可能访问所有加油站的起点则返回if cnt == n:return idxidx += cnt + 1return -1
    
  • 时间复杂度 O ( n ) O(n) O(n),空间复杂度 O ( 1 ) O(1) O(1)

15. [困难] 分发糖果

  • 题目链接
  • 标签:贪心、数组
    在这里插入图片描述

15.1 解法1:两次遍历

  • “相邻的孩子中,评分高的孩子必须获得更多的糖果” 这一句话可以拆分成两个规则
    1. 左规则:ratings[i-1]<ratings[i] 时,i 号的糖果比 i-1 号多
    2. 右规则:ratings[i]>ratings[i+1] 时,i 号的糖果比 i+1 号多
  • 单独处理其中任意一个规则是简单的,以左规则为例,初始化分配糖果数为1,从左到右遍历,若分数递增则分配糖果数+1,反之重置为1。右规则同理。
    1. 对于仅满足左规则的分配数组 L,其在每一个分数递增段都从1开始递增,其余部分全是1
    2. 对于仅满足右规则的分配数组 R,其在每一个分数递减段都递减到1,其余部分全是1
  • 经过两次遍历得到 LR 后,直接给第 i i i 个小孩分配 max(L[i], R[i]) 颗糖果即可。为了分析这种操作的正确性,假设 L [ i ] > R [ i ] L[i] > R[i] L[i]>R[i],则 max ⁡ ( L [ i ] , R [ i ] ) = L [ i ] \max(L[i], R[i]) = L[i] max(L[i],R[i])=L[i],此时左规则一定满足,考虑右规则
    1. ratings[i]>ratings[i+1],此时分配数量 L [ i ] > R [ i ] > R [ i + 1 ] L[i]>R[i]>R[i+1] L[i]>R[i]>R[i+1] 一定满足右规则
    2. ratings[i-1]>ratings[i],这意味着 i i i 处于一个递减序列内,此时 L [ i ] = 1 L[i]=1 L[i]=1,不可能有 L [ i ] > R [ i ] L[i] > R[i] L[i]>R[i],故增加给第 i i i 个小孩的糖果数量不会导致在 i − 1 i-1 i1 处违反右规则
  • 综上,给出如下的求解代码
    class Solution:def candy(self, ratings: List[int]) -> int:n = len(ratings)# 仅考虑左规则对应的最少糖果分配left = [1, ]for i in range(n-1):left.append(left[i] + 1 if ratings[i+1] > ratings[i] else 1)# 仅考虑右规则对应的最少糖果分配ratings.reverse()right = [1, ]for i in range(n-1):right.append(right[i] + 1 if ratings[i+1] > ratings[i] else 1)right.reverse()# max 操作确定每个索引处同时满足左右规则的糖果数,求和return sum([max(l, r) for l, r in zip(left, right)])
    
  • 时间复杂度 O ( n ) O(n) O(n),空间复杂度 O ( n ) O(n) O(n)

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/733636.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Fastjson 1.2.24 反序列化导致任意命令执行漏洞复现(CVE-2017-18349)

写在前面 CVE-2017-18349 指的是 fastjson 1.2.24 及之前版本存在的反序列化漏洞&#xff0c;fastjson 于 1.2.24 版本后增加了反序列化白名单&#xff1b; 而在 2019 年&#xff0c;fastjson 又被爆出在 fastjson< 1.2.47 的版本中&#xff0c;攻击者可以利用特殊构造的 …

简述epoll实现

所有学习笔记&#xff1a;https://github.com/Dusongg/StudyNotes 文章目录 epoll数据结构的选择&#xff1f;以tcp为例&#xff0c;网络io的可读可写如何判断&#xff1f;epoll如何做到线程安全&#xff1f;LT和ET如何实现&#xff1f;tcp状态和io的读写有哪些关系&#xff1…

【C语言】linux内核tcp_write_xmit和tcp_write_queue_purge

tcp_write_xmit 一、讲解 这个函数 tcp_write_xmit 是Linux内核TCP协议栈中的一部分&#xff0c;其基本作用是发送数据包到网络。这个函数会根据不同情况推进发送队列的头部&#xff0c;确保只要远程窗口有空间&#xff0c;就可以发送数据。 下面是对该函数的一些主要逻辑的中…

Spring Boot单元测试与热部署简析

1 Spring Boot的简介 Spring Boot是一个用于构建独立的、生产级别的Spring应用程序的框架。它简化了Spring应用程序的开发过程&#xff0c;提供了自动配置和默认配置&#xff0c;使得开发者只需专注于业务逻辑的实现&#xff0c;而不用去关注繁琐的配置问题。 Spring …

ElasticSearch 底层读写原理

ElasticSearch 底层读写原理 ​ 写请求是写入 primary shard&#xff0c;然后同步给所有的 replica shard&#xff1b;读请求可以从 primary shard 或 replica shard 读取&#xff0c;采用的是随机轮询算法。 1、ES写入数据的过程 1.选择任意一个DataNode发送请求&#xff0c…

Java17 --- springCloud之LoadBalancer

目录 一、LoadBalancer实现负载均衡 1.1、创建两个相同的微服务 1.2、在客户端80引入loadBalancer的pom 1.3、80服务controller层&#xff1a; 一、LoadBalancer实现负载均衡 1.1、创建两个相同的微服务 1.2、在客户端80引入loadBalancer的pom <!--loadbalancer-->&…

WPF 窗口添加投影效果Effect

BlurRadius&#xff1a;阴影半径 Color&#xff1a;颜色 Direction&#xff1a;投影方向 ShadowDepth&#xff1a;投影的深度 <Window.Effect><DropShadowEffect BlurRadius"10" Color"#FF858484" Direction"300" ShadowDepth&quo…

LLM长上下文外推方法

现在的LLM都集中在卷上下文长度了&#xff0c;最新的Claude3已经支持200K的上下文&#xff0c;见&#xff1a;cost-context。下面是一些提升LLM长度外推能力的方法总结&#xff1a; 数据工程 符尧大佬的最新工作&#xff1a;Data Engineering for Scaling Language Models to …

【Nestjs实操】环境变量和全局配置

一、环境变量 1、使用dotenv 安装pnpm add dotenv。 根目录下创建.env文件&#xff0c;内容如下&#xff1a; NODE_ENVdevelopment使用 import {config} from "dotenv"; const path require(path); config({path:path.join(__dirname,../.env)}); console.log(…

探索代理服务器:保护您的网络安全与隐私

&#x1f34e;个人博客&#xff1a;个人主页 &#x1f3c6;个人专栏&#xff1a;Linux ⛳️ 功不唐捐&#xff0c;玉汝于成 目录 前言 正文 隐藏真实IP地址&#xff1a; 访问控制&#xff1a; 加速访问速度&#xff1a; 过滤内容&#xff1a; 突破访问限制&#xff1…

Python图像处理:1.插值、频域变换与对比度增强

一、几何变换 7.图像的插值 (1)原理介绍 下面对比三种插值方法&#xff0c;分别是最近邻插值法、双线性插值法、卷积插值法&#xff0c;三种方法的前提和特点、优缺点、适用场景如下&#xff1a; 最近邻插值&#xff08;Nearest Neighbor Interpolation&#xff09;&#xf…

Linux网络套接字补充

(&#xff61;&#xff65;∀&#xff65;)&#xff89;&#xff9e;嗨&#xff01;你好这里是ky233的主页&#xff1a;这里是ky233的主页&#xff0c;欢迎光临~https://blog.csdn.net/ky233?typeblog 点个关注不迷路⌯▾⌯ 目录 一、地址转换函数 二、TCP协议通讯流程 三、…

线上应用部署了两台load为1四核服务器

线上应用部署了两台服务器。 项目发布后&#xff0c;我对线上服务器的性能进行了跟踪&#xff0c;发现一台负载为3&#xff0c;另一台负载为1&#xff0c;其中一台四核服务器已经快到瓶颈了&#xff0c;所以我们紧急排查原因。 1、使用TOP命令查看占用CPU较大的负载和进程&…

JavaWeb基础入门——(二)MySQL数据库基础(2-SQL 结构化查询语言)

四、MySQL逻辑结构 4.1 逻辑结构 4.1 记录 五、SQL 结构化查询语言 5.1 SQL概述 SQL&#xff08;Structural Query Language&#xff09;结构化查询语言&#xff0c;用于存取、查询、更新数据以及管理关系型数据库系统 5.1.1 SQL发展 SQL是在1981年由IBM公司推出&#xff0c;…

深入理解 Webpack 热更新原理:提升开发效率的关键

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…

了解华为(PVID VLAN)与思科的(Native VLAN)本征VLAN的区别并学习思科网络中二层交换机的三层结构局域网VLAN配置

一、什么是二层交换机&#xff1f; 二层交换机&#xff08;Layer 2 Switch&#xff09;是一种网络设备&#xff0c;主要工作在OSI模型的数据链路层&#xff08;第二层&#xff09;&#xff0c;用于在局域网内部进行数据包的交换和转发。二层交换机通过学习MAC地址表&#xff0…

计算机服务器中了locked勒索病毒怎么解密,locked勒索病毒解密流程

科技的发展带动了企业生产&#xff0c;越来越多的企业开始利用计算机服务器办公&#xff0c;为企业的生产运营提供了极大便利&#xff0c;但随之而来的网络安全威胁也引起了众多企业的关注。近日&#xff0c;云天数据恢复中心接到许多企业的求助&#xff0c;企业的计算机服务器…

arthas之生产环境排查问题常用功能

背景 生产环境调试使用。对问题进行高效排查。 目录 一、watch idea安装arthas插件 idea插件下载代理配置 A. 选择Http Proxy Settings, 打开配置页面B. 选择 Auto-detect proxy settingC. 上图中选择Ok即可, plugin 列表 刷新得到插件内容 启动arthas客户端watch监听 通过art…

(关键点检测)YOLOv8实现多类人体姿态估计的输出格式分析

&#xff08;关键点检测&#xff09;YOLOv8实现多类人体姿态估计的输出格式分析 任务分析 所使用的数据配置文件 网络结构 导出模型 用 netron 可视化 输出格式分析 参考链接 1. 任务分析 判断人体关键点时一并给出关键点所属的类别&#xff0c;比如男人&#xff0c;女…

【Redis知识点总结】(二)——Redis高性能IO模型剖析

Redis知识点总结&#xff08;二&#xff09;——Redis高性能IO模型及其事件驱动框架剖析 IO多路复用传统的阻塞式IO同步非阻塞IOIO多路复用机制 Redis的IO模型Redis的事件驱动框架 IO多路复用 Redis的高性能的秘密&#xff0c;在于它底层使用了IO多路复用这种高性能的网络IO&a…