当「华为还是备选，迪爹还是迪子」时宇宙厂一面原题

写在前面

alt

2021 年还是互联网元年，当时常规的华为 Offer 还是普遍人的备选，如今的迪爹（BYD）也还是 "来投就给 Offer" 的迪子。

只有字节，当时是公认炙手可热的"宇宙厂"。

作为在 2021 就提前体验了这两年计算机的"供过于求"的字节，自然在算法题上的难度要超出其他大厂招聘的一档。

那么这道「中国互联网鼎盛时期 中的 鼎盛大厂」的算法笔题，现在的你能做出来吗？

题目描述

这是 LeetCode 上的 「1268. 搜索推荐系统」 ，难度为 「中等」。

Tag : 「排序」、「字典树」、「哈希表」、「二分」

给你一个产品数组 products 和一个字符串 searchWord，products 数组中每个产品都是一个字符串。

请你设计一个推荐系统，在依次输入单词 searchWord 的每一个字母后，推荐 products 数组中前缀与 searchWord 相同的最多三个产品。如果前缀相同的可推荐产品超过三个，请按字典序返回最小的三个。

请你以二维列表的形式，返回在输入 searchWord 每个字母后相应的推荐产品的列表。

示例 1：

输入：products = ["mobile","mouse","moneypot","monitor","mousepad"], searchWord = "mouse"
输出：[
["mobile","moneypot","monitor"],
["mobile","moneypot","monitor"],
["mouse","mousepad"],
["mouse","mousepad"],
["mouse","mousepad"]
]

解释：按字典序排序后的产品列表是 ["mobile","moneypot","monitor","mouse","mousepad"]
输入 m 和 mo，由于所有产品的前缀都相同，所以系统返回字典序最小的三个产品 ["mobile","moneypot","monitor"]
输入 mou， mous 和 mouse 后系统都返回 ["mouse","mousepad"]

示例 2：

输入：products = ["havana"], searchWord = "havana"

输出：[["havana"],["havana"],["havana"],["havana"],["havana"],["havana"]]

示例 3：

输入：products = ["bags","baggage","banner","box","cloths"], searchWord = "bags"

输出：[["baggage","bags","banner"],["baggage","bags","banner"],["baggage","bags"],["bags"]]

示例 4：

输入：products = ["havana"], searchWord = "tatiana"

输出：[[],[],[],[],[],[],[]]

提示：

  • products[i] 中所有的字符都是小写英文字母。
  • searchWord 中所有字符都是小写英文字母。

排序 + 字典树 + 哈希表

为了方便，将 products 记为 ps，将 searchWord 记为 w。

这是一个 "Suggestion string" 问题，容易想到字典树进行求解，不了解字典树的同学，可看 前置 🧀。

由于题目要求「若有超过三个的产品可推荐，返回字典序最小的三个」，我们不妨先对 ps 进行排序，使 ps 从前往后满足字典序从小到大。

「将所有 ps[i] 按顺序添加到字典树 tr 中，添加过程中，使用两个哈希表 minMap 和 maxMap 分别记录经过某个 tr[i][j] 时的最小 ps 下标和最大 ps 下标」。即哈希表的 key 为具体的 tr[i][j]，对应 value 为经过该节点的最小或最大下标。

构建答案时，「根据当前 w 子串到字典树 tr 中查询，定位到该子串对应的 tr[i][j] 为何值，再从哈希表中获取建议字符串在 ps 中的左右端点 l 和 r，」并根据在 ps[l:r] （可能为空集）中最多取三个的原则来构建答案。

考虑实现字典树的两个关键方法，「添加」 和 「查询」：

  • 添加函数 void add(String s, int num) ：其中 s 为待添加到字典树的字符串，num 则是该字符串在 ps 中的下标编号。

    往字典树添加过程中，按照首次访问字典树节点 tr[i][j] 的下标存入 minMap，最后一次访问字典树节点 tr[i][j] 的下标存入 maxMap 的规则来更新哈希表。

  • 查询函数 int[] query(String s)：其中 s 为某个 w 子串，通过查询该子串（最后字符）在字典树的节点值，来得知建议列表对应 ps 的左右端点下标为何值，从而构建答案。

Java 代码：

class Solution {
    int[][] tr = new int[20010][26];
    int idx = 0;
    Map<Integer, Integer> min = new HashMap<>(), max = new HashMap<>();
    void add(String s, int num) {
        int p = 0;
        for (int i = 0; i < s.length(); i++) {
            int u = s.charAt(i) - 'a';
            if (tr[p][u] == 0) {
                tr[p][u] = ++idx;
                min.put(tr[p][u], num);
            }
            max.put(tr[p][u], num);
            p = tr[p][u];
        }
    }
    int[] query(String s) {
        int a = -1, b = -1, p = 0;
        for (int i = 0; i < s.length(); i++) {
            int u = s.charAt(i) - 'a';
            if (tr[p][u] == 0) return new int[]{-1, -1};
            a = min.get(tr[p][u]); b = max.get(tr[p][u]);
            p = tr[p][u];
        }
        return new int[]{a, b};
    }
    public List<List<String>> suggestedProducts(String[] ps, String w) {
        Arrays.sort(ps);
        List<List<String>> ans = new ArrayList<>();
        for (int i = 0; i < ps.length; i++) add(ps[i], i);
        for (int i = 0; i < w.length(); i++) {
            List<String> list = new ArrayList<>();
            int[] info = query(w.substring(0, i + 1));
            int l = info[0], r = info[1];
            for (int j = l; j <= Math.min(l + 2, r) && l != -1; j++) list.add(ps[j]);
            ans.add(list);
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    int tr[20010][26] = {0};
    int idx = 0;
    unordered_map<int, int> minMap, maxMap;
    void add(string s, int num) {
        int p = 0;
        for (char c : s) {
            int u = c - 'a';
            if (tr[p][u] == 0) {
                tr[p][u] = ++idx;
                minMap[tr[p][u]] = num;
            }
            maxMap[tr[p][u]] = num;
            p = tr[p][u];
        }
    }
    pair<int, int> query(string s) {
        int a = -1, b = -1, p = 0;
        for (char c : s) {
            int u = c - 'a';
            if (tr[p][u] == 0) return {-1, -1};
            a = minMap[tr[p][u]];
            b = maxMap[tr[p][u]];
            p = tr[p][u];
        }
        return {a, b};
    }
    vector<vector<string>> suggestedProducts(vector<string>& ps, string w) {
        sort(ps.begin(), ps.end());
        vector<vector<string>> ans;
        for (int i = 0; i < ps.size(); i++) add(ps[i], i);
        for (int i = 0; i < w.length(); i++) {
            vector<string> list;
            pair<int, int> info = query(w.substr(0, i + 1));
            int l = info.first, r = info.second;
            for (int j = l; j <= min(l + 2, r) && l != -1; j++) list.push_back(ps[j]);
            ans.push_back(list);
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def suggestedProducts(self, ps: List[str], w: str) -> List[List[str]]:
        tr = defaultdict(lambda: defaultdict(int))
        idx = 0
        minMap, maxMap = {}, {}
        def add(s, num):
            nonlocal idx
            p = 0
            for c in s:
                u = ord(c) - ord('a')
                if tr[p][u] == 0:
                    idx += 1
                    tr[p][u] = idx
                    minMap[tr[p][u]] = num
                maxMap[tr[p][u]] = num
                p = tr[p][u]
        def query(s):
            a, b, p = -1, -1, 0
            for c in s:
                u = ord(c) - ord('a')
                if tr[p][u] == 0:
                    return (-1, -1)
                a = minMap[tr[p][u]]
                b = maxMap[tr[p][u]]
                p = tr[p][u]
            return (a, b)
        ps.sort()
        ans = []
        for i in range(len(ps)):
            add(ps[i], i)
        for i in range(len(w)):
            l, r = query(w[:i + 1])
            lst = [ps[j] for j in range(l, min(l + 3, r + 1)) if l != -1]
            ans.append(lst)
        return ans

TypeScript 代码：

let tr: number[][];
let idx: number;
let minMap: Map<number, number>, maxMap: Map<number, number>;
function add(s: string, num: number): void {
    let p = 0;
    for (let i = 0; i < s.length; i++) {
        const u = s.charCodeAt(i) - 'a'.charCodeAt(0);
        if (tr[p][u] === 0) {
            idx++;
            tr[p][u] = idx;
            minMap.set(tr[p][u], num);
        }
        maxMap.set(tr[p][u], num);
        p = tr[p][u];
    }
}
function query(s: string): number[] {
    let a = -1, b = -1, p = 0;
    for (let i = 0; i < s.length; i++) {
        const u = s.charCodeAt(i) - 'a'.charCodeAt(0);
        if (tr[p][u] === 0) return [-1, -1];
        a = minMap.get(tr[p][u])!;
        b = maxMap.get(tr[p][u])!;
        p = tr[p][u];
    }
    return [a, b];
}
function suggestedProducts(ps: string[], w: string): string[][] {
    tr = new Array(20010).fill(0).map(() => new Array(26).fill(0));
    idx = 0;
    minMap = new Map(), maxMap = new Map();
    ps.sort();
    const ans = [];
    for (let i = 0; i < ps.length; i++) add(ps[i], i);
    for (let i = 0; i < w.length; i++) {
        const list = [];
        const [l, r] = query(w.substring(0, i + 1));
        for (let j = l; j <= Math.min(l + 2, r) && l !== -1; j++) list.push(ps[j]);
        ans.push(list);
    }
    return ans;
};
  • 时间复杂度：将 ps 长度记为 n， w 长度记为 m。对 ps 进行排序复杂度为 ；构建字典树复杂度为 ；根据 w 构建答案复杂度为 ；整体复杂度为
  • 空间复杂度： ，其中 为字符集大小

排序 + 二分

由于每个 w 子串只会对应最多三个的建议字符串，同时又可以先通过排序来确保 ps 的有序性。

因此对于每个 w 子串而言，可以 「先找到满足要求的，字典序最小的建议字符串 ps[i]，接着往后逐个检查，组成最终的建议字符串列表（最多检查三个）」。

这个「在 ps 中找符合要求，字典序最小的建议字符串」操作，除了能够利用上述解法来做（省掉一个 maxMap）以外，还能利用字符串本身的有序性进行「二分」，因为该操作本质上，是在「找第一个满足 ps[i] 大于等于当前子串的位置」。

Java 代码：

class Solution {
    public List<List<String>> suggestedProducts(String[] ps, String w) {
        Arrays.sort(ps);
        int n = ps.length;
        List<List<String>> ans = new ArrayList<>();
        for (int i = 0; i < w.length(); i++) {
            String cur = w.substring(0, i + 1);
            int l = 0, r = n - 1;
            while (l < r) {
                int mid = l + r >> 1;
                if (ps[mid].compareTo(cur) >= 0) r = mid;
                else l = mid + 1;
            }
            List<String> list = new ArrayList<>();
            if (ps[r].compareTo(cur) >= 0) {
                for (int j = r; j <= Math.min(n - 1, r + 2); j++) {
                    if (ps[j].length() < cur.length()) break;
                    if (!ps[j].substring(0, i + 1).equals(cur)) break;
                    list.add(ps[j]);
                }
            }
            ans.add(list);
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<vector<string>> suggestedProducts(vector<string>& ps, string w) {
        sort(ps.begin(), ps.end());
        int n = ps.size();
        vector<vector<string>> ans;
        for (int i = 0; i < w.length(); i++) {
            string cur = w.substr(0, i + 1);
            int l = 0, r = n - 1;
            while (l < r) {
                int mid = (l + r) >> 1;
                if (ps[mid].compare(cur) >= 0) r = mid;
                else l = mid + 1;
            }
            vector<string> list;
            if (ps[r].compare(cur) >= 0) {
                for (int j = r; j <= min(n - 1, r + 2); j++) {
                    if (ps[j].length() < cur.length()) break;
                    if (ps[j].substr(0, i + 1) != cur) break;
                    list.push_back(ps[j]);
                }
            }
            ans.push_back(list);
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def suggestedProducts(self, ps: List[str], w: str) -> List[List[str]]:
        ps.sort()
        n = len(ps)
        ans = []
        for i in range(len(w)):
            cur = w[:i + 1]
            l, r = 0, n - 1
            while l < r:
                mid = (l + r) // 2
                if ps[mid] >= cur:
                    r = mid
                else:
                    l = mid + 1
            lst = []
            if ps[r] >= cur:
                for j in range(r, min(n - 1, r + 2) + 1):
                    if len(ps[j]) < len(cur) or ps[j][:i + 1] != cur:
                        break
                    lst.append(ps[j])
            ans.append(lst)
        return ans

TypeScript 代码：

function suggestedProducts(ps: string[], w: string): string[][] {
    ps.sort();
    const n = ps.length;
    const ans = [];
    for (let i = 0; i < w.length; i++) {
        const cur = w.substring(0, i + 1);
        let l = 0, r = n - 1;
        while (l < r) {
            const mid = (l + r) >> 1;
            if (ps[mid].localeCompare(cur) >= 0) r = mid;    
            else l = mid + 1;
        }
        const list: string[] = [];
        if (ps[r].localeCompare(cur) >= 0) {
            for (let j = r; j <= Math.min(n - 1, r + 2); j++) {
                if (ps[j].length < cur.length || !ps[j].startsWith(cur)) break;
                list.push(ps[j]);
            }
        }
        ans.push(list);
    }
    return ans;
};
  • 时间复杂度：将 ps 长度记为 n， w 长度记为 m。对 ps 进行排序复杂度为 ；每次二分需要进行字符串比较，复杂度为 ；二分到左端点后需要往后检查最多三个字符串，复杂度为 。整体复杂度为
  • 空间复杂度：

最后

这是我们「刷穿 LeetCode」系列文章的第 No.1268 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。

在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。

为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。

在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉

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

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

相关文章

青少年心肺复苏培训公益课堂在京开讲

青少年心肺复苏培训公益课堂在京开讲

7月30日上午&#xff0c;北京中康联公益基金会联合首都医科大学附属北京佑安医院心血管内科共同举办了“互佑心安——青少年心肺复苏培训公益课堂”。 突发疾病与意外伤害&#xff0c;是生存与健康的最大威胁。据统计&#xff0c;每年全球约有700万人死于心源性猝死&#xff0c…
阅读更多...
Oracle Linux 9.3 发布

Oracle Linux 9.3 发布

导读Oracle Linux 9 系列发布了第 3 个版本更新&#xff0c;支持 64 位 Intel 和 AMD (x86_64) 以及 64 位 Arm (aarch64) 平台。与所有的 Oracle Linux 版本一样&#xff0c;此版本与相应 RHEL 版本 100% 应用二进制兼容。 对于 x86_64 和 aarch64 架构&#xff0c;Oracle Li…
阅读更多...
跨境电商系统开发：开启全球贸易新纪元

跨境电商系统开发：开启全球贸易新纪元

随着全球电子商务的飞速发展&#xff0c;跨境电子商务已经成为了一种日益重要的贸易形式。跨境电商系统开发&#xff0c;为企业提供了全新的商业机遇&#xff0c;打开了全球贸易的新纪元。 跨境电商系统开发&#xff0c;旨在实现不同国家和地区之间的电子商务交易&#xff0c;促…
阅读更多...
牛客 算法题 【HJ102 字符统计】 golang实现

牛客 算法题 【HJ102 字符统计】 golang实现

题目 HJ102 字符统计 golang代码实现 package mainimport ("bufio""fmt""os""sort" )func main() {// str_arry :make([]string, 0)str_map : make(map[rune]int)result_map : make(map[int][]string)scanner : bufio.NewScanner(os…
阅读更多...
大公司为什么喜欢centos系统写爬虫？

大公司为什么喜欢centos系统写爬虫？

CentOS是一个基于Red Hat Enterprise Linux&#xff08;RHEL&#xff09;源代码构建的开源操作系统&#xff0c;它受到大企业喜欢大多数因为他系统的稳定性&#xff0c;安全性以及兼容性等。可以为企业提供更多的商业支持。以我个人为例&#xff0c;公司在做爬虫数据抓取多是采…
阅读更多...
[⑥ADRV902x]: 软件系统初始化流程学习

[⑥ADRV902x]: 软件系统初始化流程学习

前言 本篇博客主要记录ADRV902x参考软件中对ADRV902x系统的初始化流程&#xff0c;使用API函数来实现transceiver的配置&#xff0c;校准和控制等。官方将整个系统初始化称之为multichip synchronization initialization (MCS) sequence&#xff0c;主要分成PreMcsInit&#x…
阅读更多...
jQuery_07 函数的使用

jQuery_07 函数的使用

在jQuery中&#xff0c;如何使用函数呢&#xff1f; 1.基本函数 函数(常用的) 其实有很多函数&#xff0c;但是我们只需要掌握常用的函数即可 1.val 操作dom对象的value val() 没有参数 获取dom数组中第一个dom对象的value值 val(value) 有参数 设置dom数组中所有dom对象的…
阅读更多...
企业数据建设再思考

企业数据建设再思考

近些年企业数据建设进入深水区&#xff0c;近六成受访企业高管表示在未来一到两年会增加数据建设的投入。 数据建设得分最明显的三项指标分别为&#xff1a;开拓数据变现模式、实现数据流与业务流程在各部门间的无缝衔接、搭建基于数据分析的决策体系与管控体系。 因此&#…
阅读更多...
webshell之编码免杀

webshell之编码免杀

Unicode编码 jsp支持unicode编码&#xff0c;如果杀软不支持unicode查杀的话&#xff0c;基本上都能绕过 注意这里的\uuuu00可以换成\uuuu00uuu...可以跟多个u达到绕过的效果 将代码&#xff08;除page以及标签&#xff09;进行unicode编码&#xff0c;并条件到<%%>标签…
阅读更多...
请停止在简历上写: 精通Python, 会害了你

请停止在简历上写: 精通Python, 会害了你

离了个大谱&#xff01; 瑞银暑期实习生都要求精通Python? 你以为能用Python演示“hello world" 就是精通Python了么&#xff1f; too yang too天真 一、不会Python的我们不要 1、瑞士银行 瑞士银行的暑期实习岗位JD中要求应聘者精通编程语言&#xff0c;特别是C或…
阅读更多...
SpringBoot中如何优雅地使用重试

SpringBoot中如何优雅地使用重试

1 缘起 项目中使用了第三方的服务&#xff0c; 第三方服务偶尔会出现不稳定、连接不上的情况&#xff0c; 于是&#xff0c;在调用时为了保证服务的相对高可用&#xff0c;添加了超时连接重试&#xff0c; 当连接第三方服务超时时&#xff0c;多重试几次&#xff0c;比如3次&a…
阅读更多...
C语言基础篇5：指针(一)

C语言基础篇5：指针(一)

指针是C语言的核心、精髓所在&#xff0c;用好了指针可以在C语言编程中起到事半功倍的效果。指针一方面可以提高程序的编译效率和执行速度&#xff0c;而且还可以通过指针实现动态的存储分配&#xff0c;另一方面使用指针可使程序更灵活&#xff0c;便于表示各种数据结构&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023