数据结构与算法之堆: LeetCode 295. 数据流的中位数 (Ts版)

保姆级教程:在树莓派4B上用V4L2驱动USB摄像头(附完整代码) 本文提供树莓派4B上使用V4L2驱动USB摄像头的完整教程,涵盖环境配置、V4L2架构解析、代码实现及问题排查。通过详细步骤和完整代码示例,帮助开发者快速掌握嵌入式Linux下的摄像头驱动开发,解决实际应用中的兼容性和性能问题。 阅读详情

数据流的中位数

描述

  • 中位数是有序整数列表中的中间值。如果列表的大小是偶数,则没有中间值,中位数是两个中间值的平均值。

    • 例如 arr = [2,3,4] 的中位数是 3
    • 例如 arr = [2,3] 的中位数是 (2 + 3) / 2 = 2.5
  • 实现 MedianFinder 类:

    • MedianFinder() 初始化 MedianFinder 对象
    • void addNum(int num) 将数据流中的整数 num 添加到数据结构中
    • double findMedian()返回到目前为止所有元素的中位数
    • 与实际答案相差 1 0 − 5 10^{-5} 10−5 以内的答案将被接受

示例 1

输入
["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
[[], [1], [2], [], [3], []]
输出
[null, null, null, 1.5, null, 2.0]

解释
MedianFinder medianFinder = new MedianFinder();
medianFinder.addNum(1); // arr = [1]
medianFinder.addNum(2); // arr = [1, 2]
medianFinder.findMedian(); // 返回 1.5 ((1 + 2) / 2)
medianFinder.addNum(3); // arr[1, 2, 3]
medianFinder.findMedian(); // return 2.0

提示

  • - 1 0 5 10^5 105 <= num <= 1 0 5 10^5 105
  • 在调用 findMedian 之前,数据结构中至少有一个元素
    最多 5 * 1 0 4 10^4 104 次调用 addNum 和 findMedian

Typescript 版算法实现


1 ) 方案1:优先队列

class Heap<T> {
    private heap: T[] = [];
    private compareFn: (a: T, b: T) => boolean;
 
    constructor(compareFn: (a: T, b: T) => boolean) {
        this.compareFn = compareFn;
    }
 
    swap(i: number, j: number): void {
        [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
    }
 
    getParentIndex(i: number): number {
        return Math.floor((i - 1) / 2);
    }
 
    getLeftChildIndex(pi: number): number {
        return 2 * pi + 1;
    }
 
    getRightChildIndex(pi: number): number {
        return 2 * pi + 2;
    }
 
    peek(): T | undefined {
        return this.heap[0];
    }
 
    size(): number {
        return this.heap.length;
    }
 
    insert(value: T): void {
        this.heap.push(value);
        this.shiftUp(this.size() - 1);
    }
 
    pop(): T | undefined {
        const { heap } = this;
        if (this.size() === 1) return heap.pop();
        const first = heap[0];
        heap[0] = heap.pop()!;
        this.shiftDown(0);
        return first;
    }
 
    shiftUp(i: number): void {
        if (i <= 0) return;
        const { heap } = this;
        const pi = this.getParentIndex(i);
        if (this.compareFn(heap[pi]!, heap[i]!)) {
            this.swap(pi, i);
            this.shiftUp(pi);
        }
    }
 
    shiftDown(pi: number): void {
        const { heap } = this;
        const size = this.size();
        const li = this.getLeftChildIndex(pi);
        const ri = this.getRightChildIndex(pi);
 
        if (li < size && this.compareFn(heap[pi]!, heap[li]!)) {
            this.swap(pi, li);
            this.shiftDown(li);
        }
        if (ri < size && this.compareFn(heap[pi]!, heap[ri]!)) {
            this.swap(pi, ri);
            this.shiftDown(ri);
        }
    }
}
 
class MinHeap extends Heap<number> {
    constructor() {
        super((a, b) => a > b);
    }
}
 
class MaxHeap extends Heap<number> {
    constructor() {
        super((a, b) => a < b);
    }
}
 
// 使用示例
class MedianFinder {
    private maxHeap: MaxHeap;
    private minHeap: MinHeap;
 
    constructor() {
        this.maxHeap = new MaxHeap();
        this.minHeap = new MinHeap();
    }
 
    addNum(num: number): void {
        if (this.maxHeap.size() === 0 || num <= this.maxHeap.peek()!) {
            this.maxHeap.insert(num);
        } else {
            this.minHeap.insert(num);
        }
 
        // 平衡两个堆
        if (this.maxHeap.size() > this.minHeap.size() + 1) {
            this.minHeap.insert(this.maxHeap.pop()!);
        }
        if (this.minHeap.size() > this.maxHeap.size()) {
            this.maxHeap.insert(this.minHeap.pop()!);
        }
    }
 
    findMedian(): number {
        if (this.maxHeap.size() === this.minHeap.size()) {
            return (this.maxHeap.peek()! + this.minHeap.peek()!) / 2;
        }
        return this.maxHeap.peek()!;
    }
}


/**
 * Your MedianFinder object will be instantiated and called as such:
 * var obj = new MedianFinder()
 * obj.addNum(num)
 * var param_2 = obj.findMedian()
 */
  • 超出时间限制

2 ) 方案2:优先队列-优化版

class Heap {
    protected heap: number[] = [];
    private compareFn: (a: number, b: number) => boolean;

    constructor(compareFn: (a: number, b: number) => boolean) {
        this.compareFn = compareFn;
    }

    protected swap(i: number, j: number): void {
        [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
    }

    protected getParentIndex(i: number): number {
        return (i - 1) >> 1;
    }

    protected getLeftIndex(pi: number): number {
        return (pi << 1) + 1;
    }

    protected getRightIndex(pi: number): number {
        return (pi << 1) + 2;
    }

    public peak(): number | undefined {
        return this.heap[0];
    }

    public size(): number {
        return this.heap.length;
    }

    public isEmpty(): boolean {
        return this.size() === 0;
    }

    public insert(value: number): void {
        this.heap.push(value);
        this.shiftUp(this.size() - 1);
    }

    public pop(): number | undefined {
        if (this.size() === 0) return undefined;
        if (this.size() === 1) return this.heap.pop();
        const first = this.heap[0];
        this.heap[0] = this.heap.pop()!;
        this.shiftDown(0);
        return first;
    }

    protected shiftUp(i: number): void {
        while (i > 0 && this.compareFn(this.heap[this.getParentIndex(i)], this.heap[i])) {
            this.swap(this.getParentIndex(i), i);
            i = this.getParentIndex(i);
        }
    }

    protected shiftDown(pi: number): void {
        let largest = pi;
        const left = this.getLeftIndex(pi);
        const right = this.getRightIndex(pi);

        if (left < this.size() && this.compareFn(this.heap[largest], this.heap[left])) {
            largest = left;
        }

        if (right < this.size() && this.compareFn(this.heap[largest], this.heap[right])) {
            largest = right;
        }

        if (largest !== pi) {
            this.swap(pi, largest);
            this.shiftDown(largest);
        }
    }
}

class MinHeap extends Heap {
    constructor() {
        super((a, b) => a > b); // Min-heap comparison function
    }
}

class MaxHeap extends Heap {
    constructor() {
        super((a, b) => a < b); // Max-heap comparison function
    }
}

class MedianFinder {
    private maxHeap: MaxHeap;
    private minHeap: MinHeap;

    constructor() {
        this.maxHeap = new MaxHeap(); // Max-heap for the smaller half of numbers
        this.minHeap = new MinHeap(); // Min-heap for the larger half of numbers
    }

    public addNum(num: number): void {
        if (this.maxHeap.isEmpty() || num <= this.maxHeap.peak()!) {
            this.maxHeap.insert(num);
        } else {
            this.minHeap.insert(num);
        }

        // Balance the heaps
        if (this.maxHeap.size() > this.minHeap.size() + 1) {
            this.minHeap.insert(this.maxHeap.pop()!);
        } else if (this.minHeap.size() > this.maxHeap.size()) {
            this.maxHeap.insert(this.minHeap.pop()!);
        }
    }

    public findMedian(): number {
        if (this.maxHeap.size() === this.minHeap.size()) {
            return (this.maxHeap.peak()! + this.minHeap.peak()!) / 2;
        }
        return this.maxHeap.peak()!;
    }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * var obj = new MedianFinder()
 * obj.addNum(num)
 * var param_2 = obj.findMedian()
 */

3 ) 方案3:有序集合 + 双指针

class MedianFinder {
    private nums: Map<number, number> = new Map();
    private orderedKeys: number[] = [];
    private n: number = 0;
    private left: [number, number] = [0, 0];
    private right: [number, number] = [0, 0];

    constructor() {}

    public addNum(num: number): void {
        // Update the frequency of the number in the map
        const count = this.nums.get(num) || 0;
        this.nums.set(num, count + 1);

        // Maintain the ordered keys list
        if (!this.orderedKeys.includes(num)) {
            const index = this.bisectLeft(this.orderedKeys, num);
            this.orderedKeys.splice(index, 0, num);
        }

        if (this.n === 0) {
            this.left = [num, 1];
            this.right = [num, 1];
        } else if ((this.n & 1) !== 0) {
            if (num < this.left[0]) {
                this.decrease('left');
            } else {
                this.increase('right');
            }
        } else {
            if (num > this.left[0] && num < this.right[0]) {
                this.increase('left');
                this.decrease('right');
            } else if (num >= this.right[0]) {
                this.increase('left');
            } else {
                this.decrease('right');
                this.left = [...this.right];
            }
        }
        this.n++;
    }

    public findMedian(): number {
        return (this.left[0] + this.right[0]) / 2;
    }

    private increase(iterator: 'left' | 'right'): void {
        const it = iterator === 'left' ? this.left : this.right;
        it[1]++;
        if (it[1] > (this.nums.get(it[0]) || 0)) {
            const nextKeyIndex = this.bisectLeft(this.orderedKeys, it[0] + 1);
            it[0] = nextKeyIndex < this.orderedKeys.length ? this.orderedKeys[nextKeyIndex] : this.orderedKeys[this.orderedKeys.length - 1];
            it[1] = 1;
        }
    }

    private decrease(iterator: 'left' | 'right'): void {
        const it = iterator === 'left' ? this.left : this.right;
        it[1]--;
        if (it[1] <= 0) {
            const prevKeyIndex = this.bisectRight(this.orderedKeys, it[0] - 1) - 1;
            it[0] = prevKeyIndex >= 0 ? this.orderedKeys[prevKeyIndex] : this.orderedKeys[0];
            it[1] = this.nums.get(it[0]) || 0;
        }
    }

    private bisectLeft(arr: number[], x: number): number {
        let lo = 0, hi = arr.length;
        while (lo < hi) {
            const mid = Math.floor((lo + hi) / 2);
            if (arr[mid] < x) lo = mid + 1;
            else hi = mid;
        }
        return lo;
    }

    private bisectRight(arr: number[], x: number): number {
        let lo = 0, hi = arr.length;
        while (lo < hi) {
            const mid = Math.floor((lo + hi) / 2);
            if (x < arr[mid]) hi = mid;
            else lo = mid + 1;
        }
        return lo;
    }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * var obj = new MedianFinder()
 * obj.addNum(num)
 * var param_2 = obj.findMedian()
 */
  • 超出时间限制
51单片机AHT20-21源代码 传感器输出经过 标定的数字信号,标准 I 2 C 格式。AHT20 配有一个全新设计的 ASIC专用芯片、一 个经过改进的MEMS半导体电容式湿度传感元件和一个标准的片上温度传感元件,其 性能已经大大提升甚至超出了前一代传感器的可靠性水平,新一代温湿度传感器, 经过改进使其在恶劣环境下的性能更稳定。但是现在网上的大多数原码都是针对stm32等的这种多位单片机,而我们都知道51单片机是8位单片机,无法对浮点数进行运算,对32位的整数计算有时候也不是很准确,所以我对网上stm32的例程进行了修改。... 阅读详情

相关推荐

VLA模型(具身智能入门十)

Vision Language Action(VLA)模型VLA模型是机器人领域的“感知-理解-执行”一体化框架,通过Transformer架构融合视觉、语言、动作模态,核心目标是让机器人在自然语言驱动下,自主完成复杂操控任务。其定义的核心在于“跨模态统一”与“具象化行动”——不仅能“看懂”“听懂”,更能“做出正确的动作”,是实现通用机器人智能的关键方向。提供通用序列建模骨架,让视觉、语言、动作能以“序列”形式统一处理;ViT将视觉输入转换为序列特征,提供“看”的能力;LLMs。

weixin_39699362的博客 9947

数据结构与算法笔记:字典序最大问题分析

字典序最大问题 问题描述 给定一个1到n的排列(无序状态的),依次插入到栈中,在每时每刻都可以多次从栈中弹出栈顶 问:应如何使得弹出栈顶的序列的字典序最大,并输出这个序列 问题分析 什么是字典序 比如两个序列:5,4,3,2,1和1,2,3,4,5 这两个中第一个的字典序最大 每个位置上的数字比其他序列上同一位置的数字要大 比如:第一位置中5比1大,第二位置中4比2大这样 即:字典序最大 = 从左向右看这个序列,每个数字都尽量大 题目给定一个1到n的排列,每个数字只出现一次 要使出栈的字典序最大

Wang的专栏 4396

Crazyflie 2.1固件刷写与地址配置全攻略:从开箱到连接Crazyswarm

本文详细介绍了Crazyflie 2.1微型无人机的固件刷写、地址配置及与Crazyswarm系统的集成方法。从开箱检查到多机协同飞行,涵盖了硬件准备、固件刷写、无线电地址修改等关键步骤,帮助用户快速实现集群飞行控制。特别针对Crazyswarm系统集成提供了实用配置示例和调试技巧。

weixin_42530458的博客 406

数据结构与算法笔记:农夫过河问题python3实现

问题描述 农夫(Human)过河。一个农夫带着一只狼(Wolf),一只羊(Sheep)和一些菜(Vegetable)过河。河边只有一条船,由于船太小,只能装下农夫和他的一样东西。在无人看管的情况下,狼要吃羊,羊要吃菜,请问农夫如何才能使三样东西平安过河? 要求: 输出一行,为最终的过河方式,方案格式为 过河人员、回来人员、过河人员、回来人员、…、过河人员。 过去和回来的人员之间,用空格隔开。 以四...

Wang的专栏 3374

HomeAssistant+HACS实战:5分钟搞定米家设备接入(附HomeKit配置技巧)

本文详细介绍了如何通过HomeAssistant和HACS插件商店快速接入米家设备,并分享HomeKit配置技巧。从HACS安装到米家设备接入,再到HomeKit设备集成,提供一站式智能家居解决方案,帮助用户实现设备统一管理和自动化场景设置。

weixin_29192141的博客 1052

ADC(三)Guard ring的设计艺术:从单元到系统的隔离策略

本文深入探讨了ADC设计中Guard ring(保护环)从单元到系统的多层次隔离策略。文章分享了从新手到专家的认知升级过程,详细分析了在单元内部进行微隔离、在模块间建立噪声屏障以及在系统层面规划全局隔离带的实用方法与设计艺术,强调了Guard ring对于提升混合信号电路性能和可靠性的关键作用。

weixin_28312391的博客 155

数据结构与算法笔记:计算思维之经典农夫过河问题C++实现

农夫、羊、狼、菜的过河问题 问题描述 角色:农夫,羊,狼,菜 条件1:船很小,只能装下农夫和其他一个角色 条件2:无人看管,羊吃菜,狼吃羊 问:如何让其他三种角色被农夫平安带着过河? 相关分析 我们可以先用人脑尝试一下相关渡河策略 1 ) 先渡狼,人回来再渡菜,人回来再渡羊 2 ) 先渡菜,人回来再渡狼,人回来再渡羊 以上两种很好想到,而且我们可以知道羊这种角色是不能先渡河过去的,羊需要最后再渡 如果先渡了羊了,之后再渡任何其他角色,都要将羊带回来 可以参考小游戏:http://gameschool

Wang的专栏 3314

DAC8760高精度数模转换器原理与工业级嵌入式应用

数模转换器(DAC)是工业测控系统中实现数字指令到模拟执行的关键接口,其核心性能由分辨率、线性度、温漂及系统级TUE(总未调整误差)共同决定。DAC8760作为一款16位四象限精密DAC,集成了可编程增益放大器(PGA)、内部基准源与SPI高速接口,支持电压/电流双模输出,显著提升闭环控制精度与硬件适配灵活性。其技术价值在于将高精度模拟前端与数字控制深度耦合,满足PLC、ATE及激光偏置等严苛场景对长期稳定性与多通道同步性的要求。本文围绕DAC8760的寄存器配置、HAL/LL驱动实践、PCB布局规范、现场

weixin_42315569的博客 584

数据结构与算法笔记:图搜索之DFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) !!!本文详解!!! 深度优先搜索DFS 深度优先遍历DFS, 这个策略其实是非常stupid or simple的,比BSF要简单的多 同样,我们可以通过一个故事来开始 在古希腊神话中, Ariadne是Crete的国王Minos的公主,她给忒修斯(Theseus)一个线团 使得忒修斯成功进入迷宫杀死牛头怪兽,但事后忒修斯抛弃了她 这是一个有道德意义的故事又或者存在不同的版本, 但不是我们的研究的对象

Wang的专栏 3119

注意力机制模块:注意力机制新宠:EMA 注意力(高效多尺度注意力),即插即用,涨点明显

无降维成为共识:越来越多的研究者意识到,传统注意力机制的通道降维操作会造成不可逆的信息损失。EMA 提出的“保留每个通道信息”理念正在成为新一代注意力模块的设计标准。分组并行走向成熟:特征分组 + 并行处理的设计范式已在多个前沿架构中得到验证,兼顾了表达能力和计算效率。多尺度与跨空间融合:单纯的多尺度或单纯的跨空间交互都已无法满足复杂任务需求,两者的深度融合是当前的主流方向。边缘部署导向:2026 年的新论文越来越关注在资源受限设备上的高效运行,轻量化设计成为评估注意力模块的重要指标。

ZXSXJ的博客 952

Firefox卸载卡住不动的解决方案

本文主要介绍了Firefox卸载卡住不动的解决方案,希望能对使用Windows的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案

weixin_43178406的博客 15万+

数据结构与算法笔记:计算思维之人鬼渡河问题

人鬼渡河问题 1 ) 问题描述 目标:将东岸的3人3鬼通过一只小船安全转移到西岸,希望摆渡次数尽可能少 条件 船的容量有限,一次最多只能坐2人(或2鬼或1人1鬼) 无论是在河的东岸还是在河的西岸,一旦鬼数多于人数,则人将被鬼吃掉 怎样渡河的大权掌握在人的手中 说明:划船的时间忽略不计。船一靠岸即将船与岸视为一体,人和鬼即使还没有下 船也视为已上岸 任务:编写程序,求出一种渡河方案 备注:图片托管于github,请确保网络的可访问性 2 ) 分析 目标是找

Wang的专栏 2447

代码复现5——VLMaps

报错“AttributeError: module 'clip' has no attribute 'load'”,运行下述命令解决。运行后接着报错:“ModuleNotFoundError: No module named 'pytorch_lightning'”运行后命令后会弹出一个RGB窗口,可以用键盘上的“W”“A”“D”键控制移动视角的变化,“空格”键开始记录,“q”键停止。并更改相关代码文件,vlmaps/vlmaps/lseg/modules/models/lseg_vit.py。

qq_44100524的博客 603

数据结构与算法之二叉树: LeetCode 701. 二叉搜索树中的插入操作 (Ts版)

1 ) 方案1:模拟。2 ) 方案2:递归。

Wang的专栏 2270

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

数据结构与算法笔记:计算思维之下楼梯台阶和象棋跳马问题

下台阶问题 1 ) 问题描述 从楼上走到楼下共有 h 个台阶,每一步有三种走法 走一个台阶; 走二个台阶; 走三个台阶。 问:一共可以走出多少种方案? 即共要多少步? 每一步走几级台阶? 2 ) 分析 初始思路 我们根据题目给定的场景,先简单模拟一下,设定 h=4h=4h=4 备注:图片托管于github,请确保网络的可访问性 如上图所示, 这里有4阶楼梯, 红色数字代表每一步走几级台阶 这里枚举了4层台阶的所有可能情况, 但是不管具体有几级台阶,下

Wang的专栏 2113

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

Python笔记:滑动验证码的识别算法

概述 用程序识别极验滑动验证码的验证,包括分析识别思路、识别缺口位置、生成滑块拖动路径、模拟实现滑块拼合通过验证等步骤。 准备工作 使用Python库是Selenium,浏览器为Chrome。请确保已安装Selenium库和ChromeDriver浏览器驱动。 关于极验滑动验证码: 极验滑动验证码官网为:http://www.geetest.com/ 验证方式为拖动滑块拼合图像,若图像完全拼合...

Wang的专栏 2105

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

数据结构与算法笔记:计算思维之谁做的好事与刑侦作案问题

谁做的好事 清华附中有四位同学中的一位做了好事,不留名,表扬信来了之后,校长问这四位是谁做的好事。 A说:不是我。 B说:是C。 C说:是D。 D说:他胡说。 已知:三个人说的是真话,一个人说的是假话。 现在请你根据这些信息,编写程序找出做了好事的人。 分析 将四个人说的四句话(自然语言)转换成计算机可以计算的式子, 可使用循环枚举的方式来判断 (1) 思路一:通过字符表示人 先定义一个字符变量 thisman 表示要寻找的做了好事的人的“名字(代号)”(A、B、C、D),即 char this

Wang的专栏 1835

数据结构与算法笔记:图搜索之BFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) 广度优先搜索BFS 我们可以用比喻来说明广度优先搜索算法 在一片草木枯黄的深秋草原上,在草原的某一处出现了一处野火 一开始的时候野火集中于一点之上,在这点野火耗尽当前植被变成灰烬之前点燃了周围的植被 比如节点s是初始火种,假设我们手中有一个秒表,每过1秒,我们的大火会向外迈进一步 这个过程只能向外,不能向内,因为只能点燃植被,不能把灰烬点燃 蓝色的点是即将变为灰烬的点,红色的点是刚被点燃的点,灰色的圆形或

Wang的专栏 1795

数据结构与算法之动态规划: LeetCode 1494. 并行课程 II (Ts版)

给你一个整数 n 表示某所大学里课程的数目,编号为 1 到 n ,数组 relations 中, relations[i] = [xi, yi] 表示一个先修课的关系,也就是课程 xi 必须在课程 yi 之前上。解释:上图展示了题目输入的图。一个最优方案是:第一学期上课程 2 和 3,第二学期上课程 4 ,第三学期上课程 1 ,第四学期上课程 5。然后第二个学期上课程 1 ,第三个学期上课程 4。在一个学期中,你 最多 可以同时上 k 门课,前提是这些课的先修课在之前的学期里已经上过了。

Wang的专栏 1749

数据结构与算法笔记:求直方图最大面积算法分析

直方图最大面积 问题描述 有n列的直方图,第j列高度为hjh_jhj​, 求一个面积最大的子矩阵 备注:图片托管于github,请确保网络的可访问性 格式要求 输入第一行正整数n,第二行n个空格隔开的非负整数 数据范围: 所有直方图的列不会超过30000 关键算法实现 1 ) 算法1:时间复杂度为: O(n3)O(n^3)O(n3)的实现 分析 矩形面积为底和高的乘积 底部从a到b,那么底边长为: b-a+1 高为:min{hi∣a≤i≤b}min \{h

Wang的专栏 1664

数据结构与算法之LRU: 实现 LRU 缓存算法功能 (Ts, Py, Go版)

LRU - Lease Recently Used 最近使用如果内存优先,只缓存最近使用的,删除 ‘沉睡’ 数据核心 api: get set分析。

Wang的专栏 1601

数据结构与算法之贪心: LeetCode 455. 分饼干 (Ts, Py, Go版)

对每个孩子 i,都有一个胃口值 g[i],这是能让孩子们满足胃口的饼干的最小尺寸;并且每块饼干 j,都有一个尺寸 s[j]。如果 s[j] >= g[i],我们可以将这个饼干 j 分配给孩子 i ,这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子,并输出这个最大数值。假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。2 )排序 + 双指针 + 贪心。1 )排序 + 遍历。

Wang的专栏 1568

动态规划(Dynamic Programming)详解:从入门到 LeetCode Hot 100

将一个复杂问题拆分成多个规模更小的子问题,通过保存子问题的计算结果,避免重复计算,最终得到原问题的答案。先看一个经典问题。dp[i] = 以第 i 个元素结尾的最优结果例如最长递增子序列。最长递增子序列不一定以最后一个元素结尾,因此必须遍历整个数组取最大值。dp[i] = 前 i 个元素的最优结果这种情况下,最终答案通常就是dp[n]。关键在于理解 dp 数组的定义。动态规划的核心并不是背诵某个固定模板,而是建立正确的状态定义,并通过状态转移方程解决问题。dp[i] 或 dp[i][j] 表示什么?

zengjiajun2006的博客 901

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 182

力扣73 矩阵置零

该解法通过标记含0的行和列来实现矩阵置零。遍历矩阵,用布尔数组记录有0的行和列;再遍历一次,若当前行或列被标记,则置为0。时间复杂度O(mn),空间复杂度O(m+n)。

Pniubi的博客 37

LeetCode Hot 100 二叉树专题(三):BST 二叉搜索树与右视图(Java)

本专题主线:三题(98 / 230 / 199)共用两把钥匙——BST 的中序序列严格递增,以及遍历中的"层"与"深度"标记。看懂这两点,三题共用一套模板。 结构约定:每题统一分三部分——①题目分析与解题思路(含易错点辨析);②常见解法(附代码)及讲解;③知识点总结。

2401_88612756的博客 717
上一篇: 数据结构与算法之数组: LeetCode 383. 赎金信 (Ts版)
下一篇: 数据结构与算法之推理: LeetCode 292. Nim 游戏 (Ts版)
Wang's Blog
博客等级 码龄12年 7440粉丝 2427原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值