[100天算法】-键值映射（day 42）

最新推荐文章于 2024-11-06 11:05:01 发布
最新推荐文章于 2024-11-06 11:05:01 发布
阅读量122 收藏
点赞数
分类专栏： 零基础学算法 文章标签： 算法 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoshun007/article/details/134033851
版权

题目描述

实现一个 MapSum 类里的两个方法，insert 和 sum。

对于方法 insert，你将得到一对（字符串，整数）的键值对。字符串表示键，整数表示值。如果键已经存在，那么原来的键值对将被替代成新的键值对。

对于方法 sum，你将得到一个表示前缀的字符串，你需要返回所有以该前缀开头的键的值的总和。

示例 1:

输入: insert("apple", 3), 输出: Null
输入: sum("ap"), 输出: 3
输入: insert("app", 2), 输出: Null
输入: sum("ap"), 输出: 5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/map-sum-pairs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法 1：HashMap

复杂度分析

时间空间
insertO(1) (不考虑哈希冲突的话)O(n)
sumO(n∗len(prefix))O(n)
备注n 是 hashmap 的 key 总数，prefix 是要查找的前缀n 是字符串数量

代码

Python Code

class MapSum(object):
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.hashmap = {}

    def insert(self, key, val):
        """
        :type key: str
        :type val: int
        :rtype: None
        """
        self.hashmap[key] = val

    def sum(self, prefix):
        """
        :type prefix: str
        :rtype: int
        """
        res = 0
        for key in self.hashmap:
            if key.startswith(prefix):
                res += self.hashmap[key]
        return res



# Your MapSum object will be instantiated and called as such:
# obj = MapSum()
# obj.insert(key,val)
# param_2 = obj.sum(prefix)

方法 2：Trie + DFS

思路

  • 构建前缀树。
  • sum 操作的时候，先判断 prefix 是否存在前缀树中，然后找到 prefix 最后的节点，开始 DFS。

DFS

  • 大问题：dfs(node) 应该要返回以这个节点开始的所有路径中的 value 的和。

  • 小问题：dfs(node.child)，先找到以 node 的子节点开始的所有路径中的 value 的和。不过由于 node 有很多子节点，所以我们需要一个循环。

  • 大问题与小问题的关系：当我们求出了全部 dfs(node.child)，那么

    • dfs(node) = node.value + dfs(node.child1) + dfs(node.child2) + ...

  • 递归出口：如果节点不存在，我们直接返回 0，停止递归。

复杂度分析

  • 时间复杂度：insert 操作的时间复杂度是 O(len(key))，sum 操作的时间复杂度是 O(mn)，m 是字符集中字符数量，n 是字符串长度。
  • 空间复杂度：$O(m^{n})$，m 是字符集中字符数量，n 是字符串长度。
时间空间
insertO(len(key))O(mn)
sumO(mn)O(mn)
备注m 是字符集中字符数量，n 是字符串长度

代码

TypeScript Code

class TrieNode {
    value: number;
    children: Array<TrieNode>;

    constructor(value: number) {
        this.value = value;
        this.children = Array(26);
    }
}

class MapSum {
    private root: TrieNode;

    constructor() {
        this.root = this._getTrieNode(0);
    }

    private _getTrieNode(value: number): TrieNode {
        return new TrieNode(value);
    }

    private _char2Index(char: string): number {
        return char.toLowerCase().charCodeAt(0) - 97;
    }

    insert(key: string, val: number): void {
        let crawl: TrieNode = this.root;
        for (let char of key) {
            const index: number = this._char2Index(char);
            if (!crawl.children[index]) {
                crawl.children[index] = this._getTrieNode(0);
            }
            crawl = crawl.children[index];
        }
        crawl.value = val;
    }

    private _dfs(crawl: TrieNode): number {
        if (!crawl) return 0;

        return crawl.children.reduce(
            (res: number, pointer: TrieNode): number => {
                return res + (pointer ? this._dfs(pointer) : 0);
            },
            crawl.value,
        );
    }

    sum(prefix: string): number {
        let crawl: TrieNode = this.root;
        for (let char of prefix) {
            const index: number = this._char2Index(char);
            if (!crawl.children[index]) return 0;
            crawl = crawl.children[index];
        }
        return this._dfs(crawl);
    }
}

/**
 * Your MapSum object will be instantiated and called as such:
 * var obj = new MapSum()
 * obj.insert(key,val)
 * var param_2 = obj.sum(prefix)
 */

方法 3：Trie + 时间优化

思路

在每个节点上存 prefixSum，可以把 sum 操作的时间复杂度降到 O(1)，代价是在 insert 的时候需要先检查 key 是否已经存在，存在的话要先从 prefixSum 中减去旧的 value，再加上新的 value。

复杂度分析

时间空间
insertO(len(key))O(mn)
sumO(1)O(mn)
备注m 是字符集中字符数量，n 是字符串长度

代码

class TrieNode {
    value: number;
    prefixSum: number;
    children: Array<TrieNode>;

    constructor(value: number) {
        this.value = value;
        this.prefixSum = 0;
        this.children = Array(26);
    }
}

class MapSum {
    private root: TrieNode;

    constructor() {
        this.root = this._getTrieNode(0);
    }

    private _getTrieNode(value: number): TrieNode {
        return new TrieNode(value);
    }

    private _char2Index(char: string): number {
        return char.toLowerCase().charCodeAt(0) - 97;
    }

    search(key: string): number {
        let crawl: TrieNode = this.root;
        for (let char of key) {
            const index: number = this._char2Index(char);
            if (!crawl.children[index]) return 0;
            crawl = crawl.children[index];
        }
        return crawl.value;
    }

    insert(key: string, val: number): void {
        let crawl: TrieNode = this.root;
        const existedVal: number = this.search(key);
        for (let char of key) {
            const index: number = this._char2Index(char);
            if (!crawl.children[index]) {
                crawl.children[index] = this._getTrieNode(0);
            }
            crawl = crawl.children[index];
            crawl.prefixSum = crawl.prefixSum - existedVal + val;
        }
        crawl.value = val;
    }

    sum(prefix: string): number {
        let crawl: TrieNode = this.root;

        for (let char of prefix) {
            const index: number = this._char2Index(char);
            if (!crawl.children[index]) return 0;
            crawl = crawl.children[index];
        }
        return crawl.prefixSum;
    }
}

/**
 * Your MapSum object will be instantiated and called as such:
 * var obj = new MapSum()
 * obj.insert(key,val)
 * var param_2 = obj.sum(prefix)
 */

方法 4：Trie + HashMap

思路

在方法 3 的基础上再加一个 hashmap，把以某个前缀开始的 key 和相应的 value存起来，比如，

  • 我们先插入了一个 (dark, 3)，然后再插入一个 (darkest, 2)
  • 这时的 hashmap 应该是这样：
    • { dark: 3, darkest: 2 }
  • 这时如果我们再次插入 (darkest, 5)，覆盖了之前的值，那 hashmap 就变成了：
    • { dark: 3, darkest: 5 }

复杂度分析

时间空间
insertO(len(key))O(mn)
sumO(len(prefix))O(mn)
备注m 是字符集中字符数量，n 是字符串长度

代码

class TrieNode {
    value: number;
    prefixSum: number;
    children: Array<TrieNode>;

    constructor(value: number) {
        this.value = value;
        this.prefixSum = 0;
        this.children = Array(26);
    }
}

class MapSum {
    private root: TrieNode;
    private existedWords: {
        [key: string]: number;
    };

    constructor() {
        this.root = this._getTrieNode(0);
        this.existedWords = {};
    }

    private _getTrieNode(value: number): TrieNode {
        return new TrieNode(value);
    }

    private _char2Index(char: string): number {
        return char.toLowerCase().charCodeAt(0) - 97;
    }

    insert(key: string, val: number): void {
        let crawl: TrieNode = this.root;
        for (let char of key) {
            const index: number = this._char2Index(char);
            if (!crawl.children[index]) {
                crawl.children[index] = this._getTrieNode(0);
            }
            crawl = crawl.children[index];
            if (key in this.existedWords) {
                crawl.prefixSum -= this.existedWords[key];
            }
            crawl.prefixSum += val;
        }
        this.existedWords[key] = val;
        crawl.value = val;
    }

    sum(prefix: string): number {
        let crawl: TrieNode = this.root;

        for (let char of prefix) {
            const index: number = this._char2Index(char);
            if (!crawl.children[index]) return 0;
            crawl = crawl.children[index];
        }
        return crawl.prefixSum;
    }
}

/**
 * Your MapSum object will be instantiated and called as such:
 * var obj = new MapSum()
 * obj.insert(key,val)
 * var param_2 = obj.sum(prefix)
 */
xiaoshun007～
关注
专栏目录
3天极速掌握 Scala 语言：First Day
Amo Xiang的博客
07-15 978
目录一、基础语法学习1.1 声明变量1.1.1 语法格式1.1.2 在解释器中定义一个变量1.1.3 val 和 var 变量1.1.4 使用类型推断来定义变量1.1.5 惰性赋值1.2 字符串1.2.1 使用双引号1.2.2 使用插值表达式1.2.3 使用三引号1.3 数据类型与操作符1.3.1 数据类型1.3.2 运算符1.3.3 Scala 类型层次结构1.4 条件表达式1.4.1 有返回值的 if1.4.2 块表达式1.5 循环1.5.1 for 表达式1.5.2 while 循环1.6 break
Leetcode刷题100天—706. 设计哈希映射（哈希表）—day74
智的博客
12-22 1713
前言： 作者：神的孩子在歌唱 一个算法小菜鸡 大家好，我叫智 706. 设计哈希映射 难度简单248 不使用任何内建的哈希表库设计一个哈希映射（HashMap）。 实现 MyHashMap 类： MyHashMap() 用空映射初始化对象 void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中，则更新其对应的值 value 。 int get(int key) 返回特定的 key 所映射的 value
力扣喜刷刷--day1
wumingzei的博客
07-07 749
边学习python和c边做一些题去熟悉一下面试会遇上的题目，一天学一点点，一点点长进。
python100day(16-20)
qq_49662278的博客
07-29 1038
消息队列（面向消息的中间件）的最流行和最标准化的实现是AMQP（高级消息队列协议），AMQP源于金融行业，提供了排队、路由、可靠传输、安全等功能，最著名的实现包括：Apache的ActiveMQ、RabbitMQ等。在创建一个对象的时候，对象被放在第一代中，如果在第一代的垃圾检查中对象存活了下来，该对象就会被放到第二代中，同理在第二代的垃圾检查中对象存活下来，该对象就会被放到第三代中。使用动态规划的思想，仅仅是多用了两个变量，就将原来。对象是通过类创建的，类是通过元类创建的，元类提供了创建类的元信息。
Leetcode刷题100天—169. 多数元素(哈希表)—day10
智的博客
09-04 1295
前言： 作者：神的孩子在歌唱 大家好，我叫运智 169. 多数元素 难度简单1114收藏分享切换为英文接收动态反馈 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。 你可以假设数组是非空的，并且给定的数组总是存在多数元素。 示例 1： 输入：[3,2,3] 输出：3 示例 2： 输入：[2,2,1,1,1,2,2] 输出：2 进阶： 尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。 package 哈希表;
Python100Days学习笔记---Day16-20Python语言进阶
迷途可达C的博客
03-30 763
生成式（推导式）的用法 prices = { 'AAPL': 191.88, 'GOOG': 1186.96, 'IBM': 149.24, 'ORCL': 48.44, 'ACN': 166.89, 'FB': 208.09, 'SYMC': 21.29 } # 用股票价格大于100元的股票构造一个新的字典 prices2 = {key: ...
Leetcode刷题100天—219. 存在重复元素 II(哈希表)—day11
智的博客
09-07 1594
前言： 作者：神的孩子在歌唱 大家好，我叫运智 219. 存在重复元素 II 难度简单309收藏分享切换为英文接收动态反馈 给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。 示例 1: 输入: nums = [1,2,3,1], k = 3 输出: true 示例 2: 输入: nums = [1,0,1,1], k = 1 输出: true 示例 3: 输入: nums =
【从蛋壳到满天飞】JS 数据结构解析和算法实现-集合和映射
weixin_33982670的博客
03-20 167
前言 【从蛋壳到满天飞】JS 数据结构解析和算法实现，全部文章大概的内容如下： Arrays(数组)、Stacks(栈)、Queues(队列)、LinkedList(链表)、Recursion(递归思想)、BinarySearchTree(二分搜索树)、Set(集合)、Map(映射)、Heap(堆)、PriorityQueue(优先队列)、SegmentTree(线段树)、Trie(字典树)、U...
PAT 甲级-算法初步
华鑫的学习记录
08-18 394
阅读原文 接上一篇 PAT 甲级-入门模拟 ，自我感觉这部分才是真正的算法入门，对基础的数据结构提供了很好的类型题进行匹配练习 包括分类：排序、散列、贪心、二分、双指针、打表、递推 排序 思想解释 排序题主要是获取排序后的结果而不是过程，大部分代码可以使用 sort() 函数进行直接处理，要熟练编写 cmp 排序规则（包括结构体形式的多变量规则） 有些题需要获取排名，只需在已经排序好的数组或容器中遍历全部的数据，如果和上一个数据相同，则排名相同，否则排名加 1 类型练习 1062 题目：Talent an
Day16-20 Python语言进阶
Sumarua的博客
10-24 1390
可以通过消息队列来实现应用程序的解耦合，消息队列相当于是多线程同步队列的扩展版本，不同机器上的应用程序相当于就是线程，而共享的分布式消息队列就是原来程序中的Queue。在创建一个对象的时候，对象被放在第一代中，如果在第一代的垃圾检查中对象存活了下来，该对象就会被放到第二代中，同理在第二代的垃圾检查中对象存活下来，该对象就会被放到第三代中。为了达到上述目标，需要对存钱和取钱的线程进行调度，在余额不足时取钱的线程暂停并释放锁，而存钱的线程将钱存入后要通知取钱的线程，使其从暂停状态被唤醒。
Java入门基础及面试100题--初入门
loki的博客
12-15 2581
Java入门基础及面试100题 1、面向对象的特征有哪些方面？ 答：面向对象的特征主要有以下几个方面： - 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 - 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与
Mysql高级-day03
NOBODY20142014的专栏
10-25 159
Mysql高级-day03
一文梳理2019年腾讯广告算法大赛冠军方案
Datawhale
09-23 1453
‍‍点击上方“Datawhale”，选择“星标”公众号第一时间获取价值内容作为从本次比赛共157队伍中脱颖而出的冠军方案，评分达到87.9683，从数据清洗、模型构建、目...
100种算法【Python版】第36篇——Graham Scan算法
AnFany
11-02 261
100种算法【Python版】第36篇——Graham Scan算法
算法基础-链表
August的专栏
11-05 190
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
最新发布
AnFany
11-06 146
100种算法【Python版】第51篇——希尔排序
深⼊理解指针2
ElePower9527的博客
11-01 673
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 291
华为od算法——HJ33
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1017
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
十种高效混沌映射操作在算法中的应用
在机器学习的上下文中，混沌映射被用来设计新的优化算法，这些算法利用混沌的遍历性来探索解空间，尤其是对于高维和非线性问题，混沌优化算法能够有效避免陷入局部最优，提高全局搜索能力。在人工智能领域，混沌映射...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xiaoshun007～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值