数据结构与算法之链表: LeetCode 460. LFU 缓存 (Ts版)

LFU缓存 已支持(Java & JS & Python & C) 阅读详情

LFU 缓存

描述

  • 请你为 最不经常使用(LFU)缓存算法设计并实现数据结构

  • 实现 LFUCache 类:

    • LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象
    • int get(int key) - 如果键 key 存在于缓存中,则获取键的值,否则返回 -1 。
    • void put(int key, int value) - 如果键 key 已存在,则变更其值;如果键不存在,请插入键值对。当缓存达到其容量 capacity 时,则应该在插入新项之前,移除最不经常使用的项。在此问题中,当存在平局(即两个或更多个键具有相同使用频率)时,应该去除 最久未使用 的键
  • 为了确定最不常使用的键,可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键

  • 当一个键首次插入到缓存中时,它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作,使用计数器的值将会递增

  • 函数 get 和 put 必须以 O(1) 的平均时间复杂度运行

示例:

输入:
["LFUCache", "put", "put", "get", "put", "get", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [3], [4, 4], [1], [3], [4]]
输出:
[null, null, null, 1, null, -1, 3, null, -1, 3, 4]

解释:

// cnt(x) = 键 x 的使用计数
// cache=[] 将显示最后一次使用的顺序(最左边的元素是最近的)
LFUCache lfu = new LFUCache(2);
lfu.put(1, 1);   // cache=[1,_], cnt(1)=1
lfu.put(2, 2);   // cache=[2,1], cnt(2)=1, cnt(1)=1
lfu.get(1);      // 返回 1
                 // cache=[1,2], cnt(2)=1, cnt(1)=2
lfu.put(3, 3);   // 去除键 2 ,因为 cnt(2)=1 ,使用计数最小
                 // cache=[3,1], cnt(3)=1, cnt(1)=2
lfu.get(2);      // 返回 -1(未找到)
lfu.get(3);      // 返回 3
                 // cache=[3,1], cnt(3)=2, cnt(1)=2
lfu.put(4, 4);   // 去除键 1 ,1 和 3 的 cnt 相同,但 1 最久未使用
                 // cache=[4,3], cnt(4)=1, cnt(3)=2
lfu.get(1);      // 返回 -1(未找到)
lfu.get(3);      // 返回 3
                 // cache=[3,4], cnt(4)=1, cnt(3)=3
lfu.get(4);      // 返回 4
                 // cache=[3,4], cnt(4)=2, cnt(3)=3

提示

  • 1 <= capacity <= 1 0 4 10^4 104
  • 0 <= key <= 1 0 5 10^5 105
  • 0 <= value <= 1 0 9 10^9 109
  • 最多调用 2 * 1 0 5 10^5 105 次 get 和 put 方法

Typescript 版算法实现


1 ) 方案1: 哈希表 + 平衡二叉树

class Node {
    cnt: number;
    time: number;
    key: number;
    value: number;

    constructor(cnt: number, time: number, key: number, value: number) {
        this.cnt = cnt;
        this.time = time;
        this.key = key;
        this.value = value;
    }

    static compare(a: Node, b: Node): number {
        if (a.cnt === b.cnt) {
            return a.time - b.time;
        }
        return a.cnt - b.cnt;
    }
}

class LFUCache {
    private capacity: number;
    private time: number;
    private keyTable: Map<number, Node>;
    private nodeSet: Set<Node>;

    constructor(capacity: number) {
        this.capacity = capacity;
        this.time = 0;
        this.keyTable = new Map<number, Node>();
        this.nodeSet = new Set<Node>();
    }

    private removeNode(node: Node): void {
        const toRemove = [...this.nodeSet].find(n => n.key === node.key);
        if (toRemove) {
            this.nodeSet.delete(toRemove);
        }
    }

    private addNode(node: Node): void {
        this.removeNode(node); // Ensure uniqueness based on key
        this.nodeSet.add(node);
    }

    get(key: number): number {
        if (this.capacity === 0 || !this.keyTable.has(key)) {
            return -1;
        }
        const cache = this.keyTable.get(key)!;
        this.removeNode(cache);

        cache.cnt += 1;
        cache.time = ++this.time;

        this.addNode(cache);
        this.keyTable.set(key, cache);

        return cache.value;
    }

    put(key: number, value: number): void {
        if (this.capacity === 0) {
            return;
        }

        if (!this.keyTable.has(key)) {
            if (this.keyTable.size === this.capacity) {
                // Remove the least frequently used item
                const lfuNode = [...this.nodeSet].sort(Node.compare)[0];
                if (lfuNode) {
                    this.keyTable.delete(lfuNode.key);
                    this.removeNode(lfuNode);
                }
            }
            const newNode = new Node(1, ++this.time, key, value);
            this.keyTable.set(key, newNode);
            this.addNode(newNode);
        } else {
            const cache = this.keyTable.get(key)!;
            this.removeNode(cache);

            cache.cnt += 1;
            cache.time = ++this.time;
            cache.value = value;

            this.addNode(cache);
            this.keyTable.set(key, cache);
        }
    }
}

/**
 * Your LFUCache object will be instantiated and called as such:
 * var obj = new LFUCache(capacity)
 * var param_1 = obj.get(key)
 * obj.put(key,value)
 */
  • 超出时间限制

2 ) 方案2:双哈希表 + 双向链表

class Node {
    key: number;
    val: number;
    freq: number;
    prev?: Node | null;
    next?: Node | null;

    constructor(key: number, val: number, freq: number = 1) {
        this.key = key;
        this.val = val;
        this.freq = freq;
        this.prev = null;
        this.next = null;
    }
}

class DoublyLinkedList {
    head: Node;
    tail: Node;

    constructor() {
        this.head = new Node(0, 0);
        this.tail = new Node(0, 0);
        this.head.next = this.tail;
        this.tail.prev = this.head;
    }

    pushFront(node: Node): void {
        node.prev = this.head;
        node.next = this.head.next;
        if (this.head.next) {
            this.head.next.prev = node;
        }
        this.head.next = node;
    }

    remove(node: Node): void {
        if (node.prev && node.next) {
            node.prev.next = node.next;
            node.next.prev = node.prev;
            node.next = null;
            node.prev = null;
        }
    }

    removeBack(): Node | null {
        if (this.tail.prev === this.head) return null;
        const last = this.tail.prev!;
        this.remove(last);
        return last;
    }

    isEmpty(): boolean {
        return this.head.next === this.tail;
    }
}

class LFUCache {
    private cache: Map<number, Node>;
    private freqMap: Map<number, DoublyLinkedList>;
    private minFreq: number;
    private capacity: number;

    constructor(capacity: number) {
        this.capacity = capacity;
        this.cache = new Map<number, Node>();
        this.freqMap = new Map<number, DoublyLinkedList>();
        this.minFreq = 0;
    }

    get(key: number): number {
        if (this.capacity === 0 || !this.cache.has(key)) return -1;

        const node = this.cache.get(key)!;
        this.incrFreq(node);

        return node.val;
    }

    put(key: number, value: number): void {
        if (this.capacity === 0) return;

        if (this.cache.has(key)) {
            const node = this.cache.get(key)!;
            node.val = value;
            this.incrFreq(node);
        } else {
            if (this.cache.size === this.capacity) {
                const lfuList = this.freqMap.get(this.minFreq)!;
                const removedNode = lfuList.removeBack();
                if (removedNode) {
                    this.cache.delete(removedNode.key);
                }
            }
            const newNode = new Node(key, value);
            this.addNode(newNode);
            this.cache.set(key, newNode);
            this.minFreq = 1;
        }
    }

    private incrFreq(node: Node): void {
        const list = this.freqMap.get(node.freq)!;
        list.remove(node);
        if (list.isEmpty()) {
            this.freqMap.delete(node.freq);
            if (node.freq === this.minFreq) {
                this.minFreq++;
            }
        }

        node.freq++;
        this.addNode(node);
    }

    private addNode(node: Node): void {
        let list = this.freqMap.get(node.freq);
        if (!list) {
            list = new DoublyLinkedList();
            this.freqMap.set(node.freq, list);
        }
        list.pushFront(node);
    }
}

/**
 * Your LFUCache object will be instantiated and called as such:
 * var obj = new LFUCache(capacity)
 * var param_1 = obj.get(key)
 * obj.put(key,value)
 */

3 ) 方案3:map + set

class LFUCache {
    size: number;
    values: Map<number, number> = new Map();
    times: Map<number, number> = new Map();
    useMap: Map<number, Set<number>> = new Map();
    min: number;

    constructor(capacity: number) {
        // 缓存空间大小
        this.size = capacity;
        // 缓存存储
        this.values = new Map(); // key:value
        this.times = new Map(); // key:次数
        // 找到当前次数最小的key
        // useMap更新的逻辑,其实vue的响应式依赖管理很像
        this.useMap = new Map(); //次数:key,set(key)
        this.min = 0; //最小次数是多少
    }

    get(key: number): number {
        if (this.values.has(key)) {
            // 更新计数
            this.updateCount(key);
            return this.values.get(key);
        }
        return -1;
    }

    put(key: number, value: number): void {
        //缓存空间为0,不操作
        if (this.size === 0) return;
        if (this.values.has(key)) {
            // key值存在,不需要淘汰
            this.values.set(key, value);
            this.updateCount(key);
        } else {
            // key值不存在,判断是否超过缓存 size
            if (this.size === this.values.size) {
                // 满了需要淘汰掉次数最少的、最长时间未访问的
                let minSet = this.useMap.get(this.min);
                let minKey = minSet.keys().next().value;
                minSet.delete(minKey);
                this.values.delete(minKey);
                this.times.delete(minKey);
            }
            // 加入缓存
            this.values.set(key, value);
            // 这个数据出现了1次
            let useSet = this.useMap.get(1) || (new Set() as Set<number>);
            useSet.add(key);
            this.useMap.set(1, useSet);
            this.times.set(key, 1);
            this.min = 1;
        }
    }

    updateCount(key: number): void {
        let time = this.times.get(key);
        let useSet = this.useMap.get(time);
        if (this.min === time && useSet.size === 1) {
            // 当前次数是最小值并且这个次数set集合只有一个 key 
            this.min += 1;
        }
        time += 1;
        useSet.delete(key);
        useSet = this.useMap.get(time) || new Set();
        useSet.add(key);
        this.useMap.set(time, useSet);
        this.times.set(key, time);
    }
}

/**
 * Your LFUCache object will be instantiated and called as such:
 * var obj = new LFUCache(capacity)
 * var param_1 = obj.get(key)
 * obj.put(key,value)
 */
【LeetCode系列】高效率实现LFU 高效率实现LFU LFU(Least Frequently Used,最近最少使用算法),一种常见的缓存算法。 思想:如果一个数据在最近一段时间很少被访问到,那么可以认为在将来它被访问的可能性也很小。因此,当空间满时,最小频率访问的数据最先被淘汰。 LFU算法描述: 设计一种缓存结构,该结构在构造时确定大小,假设大小为K,并有两个功能: set(key,value):将记录(key,value)插入该结构,当缓存满时,将访问频率最低的数据置换掉; get(key):返回key对应的valu 阅读详情

相关推荐

LinuxCNC开发实战:从安装到EtherCAT配置全解析

本文详细解析LinuxCNC开发实战,从系统安装到EtherCAT总线配置全流程。涵盖实时内核优化、伺服驱动器PDO映射、HAL配置及自定义运动学开发,帮助开发者快速搭建工业级数控系统,提升运动控制精度与稳定性。

rgv234567的博客 355

【每日一题】LFU 缓存

一个缓存结构需要实现如下功能: 但是缓存最多放 K 条记录,如果新的 K + 1 条记录需要加入,就需要根据策略删掉一条记录,然后才能把新记录加入。 这个策略为:在缓存结构的 K 条记录中,哪一个 key 从进入缓存结构的时刻开始,被调用 set 或者 get 次数最少,就删掉这个key 的记录;如果调用次数最少的 key 有多个,上次调用发送最早的 key 被删除。 这个就是 LFU 缓存替换算法。实现这个结构,K 作为参数。

junxinsiwo的专栏 941

计算pi小数点后10000位

数据结构课上,老师让我们计算一下pi的10000位,复习一下面向对象。 First Try:定义一个高精度类hp(high precision),实现加减乘除,输入输出,然后随便找一个公式,比如Wallis公式,全都用hp进行计算。 现实是:大数乘大数或者大数除大数,实在是太慢了。而且Wallis公式收敛太慢。 Second Try先找到一个收敛较快的公司:BBP公式,观察公式发现,...

我的技术人生 7395

LeetCode_数据结构设计_困难_460.LFU 缓存

目录1.题目2.思路3.代码实现(Java) 1.题目 请你为最不经常使用(LFU)缓存算法设计并实现数据结构。 实现 LFUCache 类: LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象 int get(int key) - 如果键 key 存在于缓存中,则获取键的值,否则返回 -1 。 void put(int key, int value) - 如果键 key 已存在,则变更其值;如果键不存在,请插入键值对。当缓存达到其容量 capa

代码星辰的博客 881

基于h5端的视频录制和回溯功能的实现

整理了一套《前端大厂面试宝典》,包含了HTML、CSS、JavaScript、HTTP、TCP协议、浏览器、VUE、React、数据结构和算法,一共201道面试题,并对每个问题作出了回答和解析。

发果叁 3193

晶体管的 栅极gate 材料选用 多晶硅polysilicon,并采用 自对准工艺 self-aligned IC后端版图 【VLSI】

本文为了解决为什么要使用多晶硅作栅极触点的问题,先介绍了MOS管的工作原理是通过栅极上所加的电压控制漏极与源极之间电流,然后解释了栅极的材料为什么选用多晶硅,然后介绍了晶体管里栅极的自对准工艺(Self-Aligned Gate )。

Jie_MSD的博客 1万+

LeetCode Hard|【460. LFU 缓存】

private://从键到节点的映射//从频率到节点链表的映射//从节点到其在列表中位置的映射这里我们需要一个私有成员函数,也就是更新频率的函数,其实逻辑还是比较好理解的。//获取该频率对应的节点链表// 从该链表中删除该节点,因为该节点的频率注定被改变了// 如果当前频率的节点链表为空,删除该频率并更新最小频率//当前删除的频率链表为最小频率时,更新最小频率//增加节点的频率,并将其插入到新的频率-节点链表的最前面//记录每个节点在各自链表中的位置。

糖炒栗子 718

告别底噪和发热:TPA3255的PCB布局与散热设计保姆级教程(附嘉立创EDA文件)

本文详细解析TPA3255 Class D音频功放的PCB布局与散热设计,提供从电源系统分层架构到热管理系统的全流程优化方案。通过实战案例展示如何消除底噪、降低发热,并附嘉立创EDA文件,助力工程师快速设计高性能音频功放。

weixin_29208077的博客 379

LeetCode 460:LFU 缓存

LeetCode 460:LFU 缓存设计与实现 核心思路:设计一种基于 LFU(最少使用)策略的缓存结构,实现 O(1) 时间复杂度的 get 和 put 操作。采用三层数据结构: 节点类:存储键值对和使用次数 双向链表:按使用时间排序同频次节点 映射关系:通过哈希表维护键到节点的映射,以及频次到链表的映射 关键实现: 使用 TreeSet 维护当前存在的所有频次 当缓存满时,优先淘汰最小频次链表的头节点 每次访问后更新节点频次,将其移动到对应频次链表的尾部 复杂度分析: 时间复杂度:get/put 均接

m0_75126572的博客 834

33、嵌入式系统中的内存操作与实时操作系统

本博客详细探讨了嵌入式系统中的内存操作和实时操作系统(RTOS)的基本原理及应用。内容涵盖C、C++和MicroPython三种语言下的SDRAM读写示例,并结合机器人真空吸尘器的实际应用说明内存的使用场景。此外,还介绍了RTOS的核心概念、组件及其工作机制,包括任务、事件、互斥锁、信号量、队列等,并以FreeRTOS和Mbed OS为例展示了RTOS的配置与使用方法。最后,通过常见问题和实践项目加深对嵌入式系统开发的理解。

zz67890的博客 146

OpenHarmony Stage模型深度解剖:从Ability Kit到沙箱隔离的全链路底层原理

基于微内核架构,提供进程管理、内存管理、IPC通信等基础能力:包含V8引擎、ArkTS运行时、渲染引擎等核心组件:Ability Kit框架,提供应用生命周期管理、组件调度等能力:基于Stage模型的应用程序。

m0_67505153的博客 193

leetcode-460:LFU 缓存

当缓存达到其容量 capacity 时,则应该在插入新项之前,移除最不经常使用的项。在此问题中,当存在平局(即两个或更多个键具有相同使用频率)时,应该去除 最近最久未使用 的键。当一个键首次插入到缓存中时,它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作,使用计数器的值将会递增。为了确定最不常使用的键,可以为缓存中的每个键维护一个 使用计数器。int get(int key) - 如果键 key 存在于缓存中,则获取键的值,否则返回 -1。

菊头蝙蝠的博客 627

【大模型应用开发-FastAPI框架】(八)Sqlalchemy+postgresql简单增删改查

语言,为高效和高性能的数据库访问设计,实现了完整的企业级持久模型”。SQLAlchemy的理念是,的量级和性能重要于对象集合;而对象集合的抽象又重要于表和行。因此,SQLAlchemy采用了类似于。社区中成为广泛使用的ORM工具之一,不亚于Django的ORM框架。和declarative等可选插件可以让用户使用声明语法。SQLAlchemy首次发行于2006年2月,并迅速地在。SQLAlchemy“采用简单的。二、安装postgresql。一、SQLAlchemy简介。的数据映射模型,而不是其他。

2098

leetcode链表之LFU缓存

460、LFU缓存 题目: 请你为 最不经常使用(LFU)缓存算法设计并实现数据结构。 实现 LFUCache 类: LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象 int get(int key) - 如果键 key 存在于缓存中,则获取键的值,否则返回 -1 。 void put(int key, int value) - 如果键 key 已存在,则变更其值;如果键不存在,请插入键值对。当缓存达到其容量 capacity 时,则应该在插入新项之前,移除

溪语流沙的博客 674

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

算法---LeetCode 460. LFU 缓存

1. 题目 原题链接 请你为 最不经常使用(LFU)缓存算法设计并实现数据结构。 实现 LFUCache 类: LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象 int get(int key) - 如果键存在于缓存中,则获取键的值,否则返回 -1。 void put(int key, int value) - 如果键已存在,则变更其值;如果键不存在,请插入键值对。当缓存达到其容量时,则应该在插入新项之 前,使最不经常使用的项无效。在此问题中,当存在平局(即两

知北行的博客 602

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

算法leetcode 彻底搞懂LRU和LFU缓存问题

简介 LRU (Least Recently Used) 缓存,即在缓存容量达到上限的条件下,删除最久未使用过的数据,腾出空间存储新的数据。 LFU (Least Frequently Used) 缓存,即在缓存容量达到上限的条件下,删除使用频率最少的数据,当使用频率相同时,删除最久未使用的数据。 这两种缓存算法在实践中用得非常普遍,例如MySQL的内存数据页淘汰算法,Redis的淘汰策略等。 例题 1. T146. LRU缓存机制 中等 2. T460. LFU缓存 困难 以上题目均来自leetcod

pl0321的博客 988

LeetCode 460. LFU 缓存 -- 哈希查询+双向链表

实现 LFUCache 类:LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象int get(int key) - 如果键 key 存在于缓存中,则获取键的值,否则返回 -1。void put(int key, int value) - 如果键 key 已存在,则变更其值;如果键不存在,请插入键值对。当缓存达到其容量 capacity 时,则应该在插入新项之前,移除最不经常使用的项。

weixin_43918046的博客 712

高并发下的分布式缓存 | 设计和实现LFU缓存

最少使用频率 (LFU) 是一种用于管理计算机内存的缓存算法。在这种算法中,系统会跟踪缓存中每个数据被引用的次数。当缓存已满时,系统会删除引用频率最低的数据。

大厂小码农的博客 1370

三、LFU缓存

LFU(Least Frequently Used)是一种缓存替换算法,其核心思想是:①优先淘汰使用频率最低的缓存数据。②每次数据被访问时,都会记录其访问次数(即频率),当缓存容量达到上限时,淘汰访问频率最少的缓存项。

qq_53280985的博客 710

【常见缓存算法原理及其C++实现】LFU篇

一、缓存算法简介 (一)缓存算法应用背景 缓存的应用场景和范围十分广泛,下面给出其十分常见的两种应用背景: 首先,在操作系统内部,由于内存资源十分有限,而每个进程又都希望独享一块很大的内存空间。所以诞生了一种“虚拟内存”机制,它将进程的一部分内容暂留在磁盘中,在需要时再进行数据交换将其放入内存,这个过程就需要用到缓存算法机制进行置换。 其次,对于各类应用项目开发而言,在巨大的数据量面前,Cache是不可或缺的。因为无论是针对本地端的浏览器缓存,还是针...

saxon_li的博客 9225

缓存替换算法之 LFU(最少使用频率)

LFU 算法是基于访问频率的缓存替换策略,适合长时间使用的热门数据,避免频繁访问的数据被删除。虽然 LFU 具备较强的缓存适应性,但也由于其实现复杂和频率更新的开销,可能不适用于对性能要求较高的场景。

qq_50847694的博客 899

LRU LFU FIFO缓存以及代码实现

介绍了三种常见缓存策略的实现方法。LRU缓存通过哈希表+双向链表实现,将最新访问数据移至头部,淘汰尾部数据;LFU缓存优化版采用频率哈希表+双向链表结构,按使用频率维护节点;FIFO缓存借助LinkedHashMap的插入顺序特性自动淘汰最早数据。各策略均提供Java实现代码,其中LRU和优化LFU实现O(1)时间复杂度,而基础LFU使用优先队列实现O(logN)复杂度。文章对比了三种策略的数据结构选择和操作流程,并针对LFU基础实现的缺陷给出了优化方案。

持续更新中!!! 1665

Leetcode LFU_Cache缓存结构设计

之前LRU最近最久未使用缓存结构设计 采取存储方式为 map<key,List<pair<int,int>>::iterator> 存放key到(key,value)映射 可直接get到 List<pair<key,value>> 存放(key,value)链表 维护大小为k 末尾为最久未使用 题目描述 一个缓存结构需要实现...

一只老风铃 778

图解缓存淘汰算法 LRU、LFU | 最近最少使用、最不经常使用算法 | go语言实现

无论是什么系统,在研发的过程中不可避免的会使用到缓存,而缓存一般来说我们不会永久存储,但是缓存的内容是有限的,那么我们就可以使用 LRU算法,来维持缓存中的信息的时效性。

面向生活编程 2万+

深入理解 LFU 缓存算法:原理、应用与优化

本文内容包括LFU原理、实现及局部性场景。LFU(Least Frequently Used)算法是一种缓存淘汰策略,它根据数据被访问的频率来淘汰数据。LFU算法的核心思想是:如果数据被访问的频率较低,那么它在未来被访问的可能性也较低,因此可以优先考虑淘汰这些数据。

若明天不见 1374

图解 LFU 缓存淘汰算法以及在 Redis 中的应用(附带个人完整代码实现)

详细介绍 LFU 缓存淘汰算法,使用图解的方式辅助理解,并给出了完整的代码实现。除此之外,还介绍了 LFU 算法在 Redis 中的实现。

wzz2333的博客 2097
上一篇: 数据结构与算法之栈: LeetCode 503. 下一个更大元素 II (Ts版)
下一篇: 数据结构与算法之栈: LeetCode LCR 152. 验证二叉搜索树的后序遍历序列 (Ts版)
Wang's Blog
博客等级 码龄12年 7439粉丝 2424原创
评论
成就一亿技术人!
拼手气红包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、付费专栏及课程。

余额充值