TikTok真题第6天 | 146.LRU缓存、333.最大的二分搜索树、621.任务调度器

146.LRU缓存

题目链接:146.lru-cache

解法:

这个题代码量大,光看题解就1个小时多了,看完写下来花了两小时多...

使用哈希表+双向链表来实现LRU缓存的特性,即哈希表可以实现get为O(1)复杂度,双向链表可以实现put、remove都是O(1)的复杂度。

代码实现时,这里双向链表,靠近头部的键值对是最久未使用的,而靠近尾部的键值对是最近使用的。也有的实现,头部放最近使用的,尾部放最久未使用。

而删除最久未使用的node时,需要在哈希表和双向链表中都删除,那么可以由双向链表得到最久未使用的node,从而得到node的key,再从哈希表中删除,这是哈希表和双向链表之间的联系。

一个技巧是使用dummy虚拟节点,有的题解用两个dummy表示首尾节点,有的题解只用了一个dummy。个人认为写法要容易理解,简洁是其次的要求。两个dummy的写法更好理解。

题解参考labuladong,代码多一些,但是很清晰,然后翻译成了C++版本:labuladong,LRU缓存

边界条件:无

时间复杂度:对于 putget 都是 O(1)

空间复杂度:O(capacity)

cpp 复制代码
class Node {
public:
    int key, val;
    Node *pre, *next;
    Node (int k=0, int v=0): key(k), val(v), pre(nullptr), next(nullptr) {};
};

class DoubleList {
private:
    Node *head, *tail;
    int size;

public:
    DoubleList() {
        head = new Node();
        tail = new Node();
        head->next = tail;
        tail->pre = head;
        size = 0;
    }

    int getSize() {
        return size;
    }

    // 末尾的node是最近使用的
    void addLast(Node* x) {
        x->next = tail;
        x->pre = tail->pre;
        x->next->pre = x;
        x->pre->next = x;
        size++;
    }

    void remove(Node* x) {
        x->pre->next = x->next;
        x->next->pre = x->pre;
        size--;
    }

    // 开头的node是最久未使用的,返回的目的是为了在map中删除
    Node* removeFirst() {
        if (head->next == tail) return nullptr;
        Node* first = head->next;
        remove(first);
        return first;
    }
};

class LRUCache {
private:
    unordered_map<int, Node*> map;
    DoubleList cache;
    int cap;

private:
    // 用于get时,把node作为最近使用的
    void makeRecently (int key) {
        Node* node = map[key];
        cache.remove(node);
        cache.addLast(node);
    }

    void addRecently (int key, int val) {
        Node* node = new Node(key, val);
        cache.addLast(node);
        map[key] = node;
    }

    void deleteKey (int key) {
        Node* node = map[key];
        cache.remove(node);
        map.erase(key);
        delete node;
    }

    void removeLeastRecently () {
        Node* node = cache.removeFirst();
        int key = node->key;
        map.erase(key);
        delete node;
    }

public:
    LRUCache(int capacity): cap(capacity){};
    
    int get(int key) {
        // 如果不存在,则返回-1
        if (map.find(key) == map.end()) return -1;
        makeRecently(key);
        return map[key]->val;
    }
    
    void put(int key, int value) {
        // 如果存在,则先删除,再加入
        if (map.find(key) != map.end()) {
            deleteKey(key);
            addRecently(key, value);
            return;
        }
        // 如果不存在,且空间满了,则先移除最久未使用
        if (cap == cache.getSize()) {
            removeLeastRecently();
        }
        addRecently(key, value);
    }
};

333.最大的二分搜索树

题目链接:333.largest-bst-subtree

解法:

参考题解:https://www.cnblogs.com/grandyang/p/5188938.html

这个题有follow up,那么首先给出O(n^2)的解法。

每个节点都当做根节点,来验证其是否是二叉搜索数。如果当前node是二叉搜索树,就记录节点的个数,并返回节点个数,如果不是二叉搜索树,那就验证左右子树是否为二叉搜索树,分别记录节点的个数,然后取二者中的最大值进行返回。

思路可以说是DFS和分而治之(左子树和右子树分别进行DFS)。

由于每个节点都要对树遍历一次,所以时间复杂度为O(n^2)。

下面是O(n)复杂度的解法。

只允许遍历一次整个二叉树,由于满足要求的二叉搜索子树必定是有叶节点的,所以思路就是先递归到最左子节点,然后逐层往上递归。对于每一个节点,都记录当前最大的 BST 的节点数,当做为左子树的最大值,和做为右子树的最小值。

当每次遇到左子节点不存在或者当前节点值大于左子树的最大值,且右子树不存在或者当前节点值小于右子树的最小数时,说明 BST 的节点数又增加了一个,更新结果及其参数。

如果当前节点不是 BST 的节点,那么更新 BST 的节点数 res 为左右子节点的各自的 BST 的节点数的较大值。

这个O(n)的解法实在看得眼花缭乱,这次也没有理解得很好。下次再细看了。

边界条件:无

时间复杂度:O(n)

空间复杂度:O(h),树的深度

cpp 复制代码
// O(n^2)的解法
class Solution {
public:
    int largestBSTSubtree(TreeNode* root) {
        if (!root) return 0;
        // 如果root是BST,那么左右子树一定是,但root一定是比左右子树更大的BST,所以直接return
        if (isValid(root, INT_MIN, INT_MAX)) return count(root);
        return max(largestBSTSubtree(root->left), largestBSTSubtree(root->right));
    }

    bool isValid(TreeNode* root, int min, int max) {
        if (!root) return true;
        if (root->val <= min || root->val >= max) return false;
        // 该节点满足,那么继续看左右节点是否满足
        return isValid(root->left, min, root->val) && isValid(root->right, root->val, max);
    }

    int count(TreeNode* node) {
        if (!node) return 0;
        return count(node->left) + count(node->right) + 1;
    }
};
cpp 复制代码
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
// O(n)的解法
class Solution {
public:
    int largestBSTSubtree(TreeNode* root) {
        // res中有三个元素: 以当前结点为根结点的树的最小值,最大值,最大的 BST 子树的结点个数
        vector<int> res = helper(root);
        return res[2];
    }
    vector<int> helper(TreeNode* node) {
        if (!node) return {INT_MAX, INT_MIN, 0};
        vector<int> left = helper(node->left), right = helper(node->right);
        // 大于左子树的最大值,小于右子树的最小值,那么是BST
        if (node->val > left[1] && node->val < right[0]) {
            return {min(node->val, left[0]), max(node->val, right[1]), left[2] + right[2] + 1};
        } else {
            // 这里不太好理解,这是用于破坏BST规则,node->val > left[1] && node->val < right[0]
            return {INT_MIN, INT_MAX, max(left[2], right[2])};
        }
    }
};

621.任务调度器

题目链接:task-scheduler

解法:

这种题真是奇技淫巧,思想确实精妙,但是属于脑筋急转弯类型。吐槽一下,刷这些题真是浪费青春,造孽啊!

没啥好说的,直接参考题解:桶思想

边界条件:无

时间复杂度:O(nlogn),排序

空间复杂度:O(1)

cpp 复制代码
class Solution {
public:
    int leastInterval(vector<char>& tasks, int n) {
        // 总的任务数
        int len = tasks.size();
        // 统计每个任务的数量
        vector<int> vec(26);
        for (char c: tasks) {
            vec[c-'A']++;
        }
        // 按任务数量进行降序排列,任务是啥不重要了
        sort(vec.begin(), vec.end(), [](int& x, int&y) {
            return x > y;
        });
        // 统计任务数量最多,且数量相等的任务,有多少个
        int cnt = 1;
        while (cnt < vec.size() && vec[cnt] == vec[0]) {
            cnt++;
        }
        return max(len, (vec[0]-1)*(n+1)+cnt);
    }
};
相关推荐
VertexGeek9 分钟前
Rust学习(八):异常处理和宏编程:
学习·算法·rust
石小石Orz10 分钟前
Three.js + AI:AI 算法生成 3D 萤火虫飞舞效果~
javascript·人工智能·算法
jiao_mrswang1 小时前
leetcode-18-四数之和
算法·leetcode·职场和发展
qystca1 小时前
洛谷 B3637 最长上升子序列 C语言 记忆化搜索->‘正序‘dp
c语言·开发语言·算法
薯条不要番茄酱1 小时前
数据结构-8.Java. 七大排序算法(中篇)
java·开发语言·数据结构·后端·算法·排序算法·intellij-idea
今天吃饺子1 小时前
2024年SCI一区最新改进优化算法——四参数自适应生长优化器,MATLAB代码免费获取...
开发语言·算法·matlab
是阿建吖!1 小时前
【优选算法】二分查找
c++·算法
王燕龙(大卫)1 小时前
leetcode 数组中第k个最大元素
算法·leetcode
不去幼儿园2 小时前
【MARL】深入理解多智能体近端策略优化(MAPPO)算法与调参
人工智能·python·算法·机器学习·强化学习
Mr_Xuhhh2 小时前
重生之我在学环境变量
linux·运维·服务器·前端·chrome·算法