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缓存
边界条件:无
时间复杂度:对于 put
和 get
都是 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.最大的二分搜索树
解法:
参考题解: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);
}
};