2024年2月4日力扣题目训练
- 2024年2月4日力扣题目训练
-
- [455. 分发饼干](#455. 分发饼干)
- [459. 重复的子字符串](#459. 重复的子字符串)
- [463. 岛屿的周长](#463. 岛屿的周长)
- [146. LRU 缓存](#146. LRU 缓存)
- [147. 对链表进行插入排序](#147. 对链表进行插入排序)
- [76. 最小覆盖子串](#76. 最小覆盖子串)
2024年2月4日力扣题目训练
2024年2月4日第十一天编程训练，今天主要是进行一些题训练，包括简单题3道、中等题2道和困难题1道。惰性太强现在才完成，不过之后我会认真完成的。
455. 分发饼干
链接: 分发饼干
难度： 简单
题目：
运行示例：
思路：
这道题本质就是一个贪心问题，尽可能满足胃口小的孩子。
代码：
javascript
class Solution {
public:
int findContentChildren(vector<int>& g, vector<int>& s) {
int count = 0;
int i = 0, j = 0;
sort(g.begin(),g.end());
sort(s.begin(),s.end());
while(i < s.size() && j < g.size()){
if(s[i] >= g[j]){
j++;
count++;
s[i] = -1;
}else i++;
}
return count;
}
};459. 重复的子字符串
链接: 重复的子字符串
难度： 简单
题目：
运行示例：
思路：
这道题是找子字符串，可以暴力遍历完成。官方采用的是KMP算法，这样可以减少遍历的次数。
代码：
javascript
class Solution {
public:
bool repeatedSubstringPattern(string s) {
if(s.size() == 1) return false;
int i = 0,sublen = 1,j = 0;
string subs = s.substr(0,sublen);
while(i < s.size()){
if(s.size() % subs.size() != 0){
subs = s.substr(0,++sublen);
j = 0;
i = subs.size();
}else {
if(j == subs.size()) j = 0;
if(subs[j] == s[i]) {
i++;
j++;
}else{
subs = s.substr(0,++sublen);
j = 0;
i = subs.size();
}
}
}
if(subs.size() == s.size() || s.size() % subs.size() != 0) return false;
return true;
}
};463. 岛屿的周长
链接: 岛屿的周长
难度： 简单
题目：
运行示例：
思路：
对于一个陆地格子的每条边，它被算作岛屿的周长当且仅当这条边为网格的边界或者相邻的另一个格子为水域。 因此，这道题可以遍历每个陆地格子，看其四个方向是否为边界或者水域，如果是，将这条边的贡献（即 1）加入答案 ans 中即可。
代码：
javascript
class Solution {
public:
int dfs(vector<vector<int>>& grid,int i, int j){
int m = grid.size(),n = grid[0].size();
if(i < 0 || j < 0 || i >= m || j >= n || grid[i][j] == 0) return 1;
if(grid[i][j] == 2) return 0;
grid[i][j] = 2;
return dfs(grid,i-1,j)+dfs(grid,i+1,j)+dfs(grid,i,j-1)+dfs(grid,i,j+1);
}
int islandPerimeter(vector<vector<int>>& grid)
{
int ans = 0;
for(int i = 0; i < grid.size(); i++)
{
for(int j = 0; j < grid[0].size(); j++)
{
if(grid[i][j] == 1)
{
ans += dfs(grid,i,j);
}
}
}
return ans;
}
};146. LRU 缓存
链接: LRU 缓存
难度： 中等
题目：
运行示例：
思路：
这道题比较复杂考虑了双向链表、哈希表以及LRU性质等，这道题我看评论找工作时比较容易考，大家可以多看看。
代码：
javascript
struct DLinkedNode {
int key, value;
DLinkedNode* prev;
DLinkedNode* next;
DLinkedNode(): key(0), value(0), prev(nullptr), next(nullptr) {}
DLinkedNode(int _key, int _value): key(_key), value(_value), prev(nullptr), next(nullptr) {}
};
class LRUCache {
public:
unordered_map<int, DLinkedNode*> cache;
DLinkedNode* head;
DLinkedNode* tail;
int size;
int capacity;
void addToHead(DLinkedNode* node){
node->prev = head;
node->next = head->next;
head->next->prev = node;
head->next = node;
}
void removeNode(DLinkedNode* node){
node->prev->next = node->next;
node->next->prev = node->prev;
}
void moveToHead(DLinkedNode* node){
removeNode(node);
addToHead(node);
}
DLinkedNode* removeTail(){
DLinkedNode* node = tail->prev;
removeNode(node);
return node;
}
LRUCache(int _capacity): capacity(_capacity), size(0){
head = new DLinkedNode();
tail = new DLinkedNode();
head->next = tail;
tail->prev = head;
}
int get(int key) {
if(!cache.count(key)) return -1;
DLinkedNode* node = cache[key];
moveToHead(node);
return node->value;
}
void put(int key, int value) {
if(!cache.count(key)){
DLinkedNode* node = new DLinkedNode(key,value);
cache[key] = node;
addToHead(node);
size++;
if(size > capacity){
DLinkedNode* removeNode = removeTail();
cache.erase(removeNode->key);
delete removeNode;
size--;
}
}else{
DLinkedNode* node = cache[key];
node->value = value;
moveToHead(node);
}
}
};147. 对链表进行插入排序
链接: 插入排序
难度： 中等
题目：
运行示例：
思路：
这就是一个简单的链表插入，我采用了头插法。
代码：
javascript
class Solution {
public:
ListNode* insertionSortList(ListNode* head) {
if(head == NULL) return head;
ListNode* newhead = new ListNode(0);
newhead->next = head;
ListNode* p = head;
ListNode*curr = head->next;
while(curr != NULL){
if(p->val <= curr->val){
p = p->next;
}else{
ListNode* pre = newhead;
while(pre->next->val <= curr->val) pre = pre->next;
p->next = curr->next;
curr->next = pre->next;
pre->next = curr;
}
curr = p->next;
}
return newhead->next;
}
};76. 最小覆盖子串
链接: 最小覆盖子串
难度： 困难
题目：
运行示例：
思路：
这道题本质是利用互动窗口，然后利用哈希表记录t的词频，在不断变动滑动窗口时，改变哈希表中的值即可。
代码：
javascript
class Solution {
public:
string minWindow(string s, string t) {
int m = s.size();
int n = t.size();
string ans;
if(m < n) return ans;
unordered_map<char,int> visited(n);
for(int i = 0 ; i < n; i++){
visited[t[i]]++;
}
int left = 0, right = 0;
int cnt = 0;
while(left <= right && right < m){
//扩大区间
while (right < m && cnt != n) {
if(visited.find(s[right]) != visited.end()){
if(visited[s[right]] > 0){
cnt++;
}
visited[s[right]]--;
}
right++;
}
//缩小区间
if(cnt == n){
while(visited.find(s[left]) == visited.end() ||
(visited.find(s[left]) != visited.end() && visited[s[left]] < 0)){
if(visited.find(s[left])!= visited.end() && visited[s[left]] < 0){
visited[s[left]]++;
}
left++;
}
if(ans.size() == 0 || ans.size() > right - left){
ans = s.substr(left,right-left);
}
visited[s[left++]]++;
cnt--;
}
}
return ans;
}
};