From 3d2c29c6a2097092012c1843b82b682dcdceb4d3 Mon Sep 17 00:00:00 2001 From: JungHwan Date: Fri, 19 Jul 2024 00:38:03 +0900 Subject: [PATCH] 7/18 1Q --- .../Leetcode_567. Permutation in String.js | 92 +++++++++++ .../Leetcode_76. Minimum Window Substring.js | 62 +++++++ .../297_SerializeandDeserializeBinaryTree.cpp | 155 ++++++++++++++++++ .../Day14/703_KthLargestElementinaStream.cpp | 88 ++++++++++ Jongeun/Day14/78_Subsets.cpp | 35 ++++ JungHwan/Day12/NeetCode_MaxWaterContainer.py | 58 ++++++- JungHwan/Day18/NeetCode_LargestRectangle.py | 51 ++++++ 7 files changed, 533 insertions(+), 8 deletions(-) create mode 100644 Jiho/Day14/Leetcode_567. Permutation in String.js create mode 100644 Jiho/Day14/Leetcode_76. Minimum Window Substring.js create mode 100644 Jongeun/Day14/297_SerializeandDeserializeBinaryTree.cpp create mode 100644 Jongeun/Day14/703_KthLargestElementinaStream.cpp create mode 100644 Jongeun/Day14/78_Subsets.cpp create mode 100644 JungHwan/Day18/NeetCode_LargestRectangle.py diff --git a/Jiho/Day14/Leetcode_567. Permutation in String.js b/Jiho/Day14/Leetcode_567. Permutation in String.js new file mode 100644 index 0000000..00fc437 --- /dev/null +++ b/Jiho/Day14/Leetcode_567. Permutation in String.js @@ -0,0 +1,92 @@ +const fs = require("fs"); +const input = fs + .readFileSync(process.platform === "linux" ? "/dev/stdin" : "../input.txt") + .toString() + .trim() + .split("\n"); + +var checkInclusion = function (s1, s2) { + // #1. 기존set: O(N) + const set = new Map(); + for (const elm of s1.trim().split("")) { + set.set(elm, (set.get(elm) | 0) + 1); + } + + // #2. + let cnt = 0; + let cp_set = new Map(set.entries()); + console.log(cp_set); + console.log("초기: ", cp_set); + while (cp_set.size != 0 && cnt < s2.length) { + // console.log(s2[cnt]); + const target = s2[cnt]; + if (cp_set.has(target)) { + // 감소 + cp_set.set(target, cp_set.get(target) - 1); + // 삭제 + if (cp_set.get(target) === 0) { + console.log("cnt: ", cnt, "삭제: ", target); + if (cnt === 4047) { + console.log(cp_set); + } + cp_set.delete(target); + } + } + // 없는 경우 -> 초기화 + else { + // 다 소진된 경우 + if (set.has(target)) { + // 가장 최근에 나온 target 찾기 + let i = 1; + while (cnt - i >= 0 && s2[cnt - i] !== target) { + i++; + } + // console.log("i:", i); + cnt -= i; + } + cp_set = new Map(set.entries()); + } + cnt += 1; + } + return cp_set.size === 0 ? true : false; +}; + +/** + * @param {string} s1 + * @param {string} s2 + * @return {boolean} + */ +var checkInclusionsol = function (s1, s2) { + var len1 = s1.length, + len2 = s2.length; + if (len1 > len2) return false; + var count = Array(26).fill(0); + const aCharCode = "a".charCodeAt(0); + for (var i = 0; i < len1; i++) { + count[s1.charCodeAt(i) - aCharCode]++; + count[s2.charCodeAt(i) - aCharCode]--; + } + if (allZero(count)) return true; + + for (var j = len1; j < len2; j++) { + count[s2.charCodeAt(j) - aCharCode]--; + count[s2.charCodeAt(j - len1) - aCharCode]++; + if (allZero(count)) return true; + } + + return false; + + function allZero(count) { + for (var i = 0; i < 26; i++) { + if (count[i] !== 0) return false; + } + return true; + } +}; +const [str1, str2] = input; +console.log( + checkInclusion( + "vxqakfyaqahufxfizupjrkkifjlbfqfeprqrfjvxnubntdtlvz", + "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" + ) +); diff --git a/Jiho/Day14/Leetcode_76. Minimum Window Substring.js b/Jiho/Day14/Leetcode_76. Minimum Window Substring.js new file mode 100644 index 0000000..6e4d8f7 --- /dev/null +++ b/Jiho/Day14/Leetcode_76. Minimum Window Substring.js @@ -0,0 +1,62 @@ +const fs = require("fs"); +const input = fs + .readFileSync(process.platform === "linux" ? "/dev/stdin" : "../input.txt") + .toString() + .trim() + .split("\n"); + +function isValid(map) { + for (let value of map.values()) { + if (value > 0) return false; + } + return true; +} + +var minWindow = function (s, t) { + const set_t = new Map(); + for (let i = 0; i < t.length; i++) set_t.set(t[i], (set_t.get(t[i]) | 0) + 1); + + // #1. 맞는 처음 찾기 + let queue = []; + let set = new Map(set_t.entries()); + for (let i = 0; i < s.length; i++) { + if (set.has(s[i])) { + queue.push(i); + set.set(s[i], set.get(s[i]) - 1); + if (isValid(set)) break; + } + } + // 예외 처리 + if (!isValid(set)) return ""; + + // #2. 최소값 찾기 + let [l, r] = [queue[0], queue[queue.length - 1]]; + let [min_l, min_r] = [l, r]; + while (queue.length != 0) { + const left = s[queue.shift()]; // left를 r이 찾아줘야함 + set.set(left, set.get(left) + 1); + l = queue[0]; + let first_r = r; + while (r < s.length) { + // queue에 원소 추가 + if (set_t.has(s[r]) && r !== first_r) { + queue.push(r); + set.set(s[r], set.get(s[r]) - 1); + } + // 검사 + if (isValid(set)) { + if (r - l < min_r - min_l) { + min_l = l; + min_r = r; + } + break; + } + r++; + } + } + + return s.slice(min_l, min_r + 1); +}; +const [str1, str2] = input; + +console.log(minWindow(str1, str2)); diff --git a/Jongeun/Day14/297_SerializeandDeserializeBinaryTree.cpp b/Jongeun/Day14/297_SerializeandDeserializeBinaryTree.cpp new file mode 100644 index 0000000..f54250b --- /dev/null +++ b/Jongeun/Day14/297_SerializeandDeserializeBinaryTree.cpp @@ -0,0 +1,155 @@ +#include +#include +#include +#include + +using namespace std; + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Codec +{ +public: + // Encodes a tree to a single string. + string serialize(TreeNode *root) + { + queue q; + + if (root != nullptr) + { + q.push(root); + } + else + { + return ""; + } + + string s = ""; + while (!q.empty()) + { + TreeNode *temp = q.front(); + s += to_string(temp->val); + + if (temp->left) + { + q.push(temp->left); + s = s + "L" + to_string(temp->left->val); + } + if (temp->right) + { + q.push(temp->right); + s = s + "R" + to_string(temp->right->val); + } + + s += " "; // delimiter + q.pop(); + } + + return s; + } + + // Decodes your encoded data to tree. + + TreeNode *deserialize(string data) + { + + int l{0}; + int r{0}; + + if (data == "") + { + return nullptr; + } + + queue q; + + while (data[r] != 'L' && data[r] != 'R' && data[r] != ' ') + { + r++; + } + + TreeNode *head = new TreeNode(stoi(data.substr(l, r - l))); + q.push(head); + + while (r < data.size()) + { + + TreeNode *temp = q.front(); + + while (data[r] != 'L' && data[r] != 'R' && data[r] != ' ') + { + r++; + } + + if (data[r] == 'L') + { + r++; + l = r; + + while (data[r] != 'R' && data[r] != ' ') + { + r++; + } + + TreeNode *leftNode = new TreeNode(stoi(data.substr(l, r - l))); + temp->left = leftNode; + } + + if (data[r] == 'R') + { + r++; + l = r; + + while (data[r] != ' ') + { + r++; + } + + TreeNode *rightNode = new TreeNode(stoi(data.substr(l, r - l))); + temp->right = rightNode; + } + + if (data[r] == ' ') + { + r++; + l = r; + } + + q.pop(); + } + + return head; + } +}; + +// Your Codec object will be instantiated and called as such: +// Codec ser, deser; +// TreeNode* ans = deser.deserialize(ser.serialize(root)); + +int main() +{ + Codec ser, deser; + TreeNode *root = new TreeNode(1); + root->left = new TreeNode(2); + root->right = new TreeNode(3); + root->right->left = new TreeNode(4); + root->right->right = new TreeNode(5); + + string s = ser.serialize(root); + cout << s << endl; + + TreeNode *ans = deser.deserialize(s); + cout << ans->val << endl; + cout << ans->left->val << endl; + cout << ans->right->val << endl; + cout << ans->right->left->val << endl; + cout << ans->right->right->val << endl; + + return 0; +} diff --git a/Jongeun/Day14/703_KthLargestElementinaStream.cpp b/Jongeun/Day14/703_KthLargestElementinaStream.cpp new file mode 100644 index 0000000..72b951f --- /dev/null +++ b/Jongeun/Day14/703_KthLargestElementinaStream.cpp @@ -0,0 +1,88 @@ +class KthLargest +{ +public: + KthLargest(int k, vector &nums) + { + largest = k; + stream = nums; + // construct Min Heap + for (int i = nums.size() / 2 - 1; i >= 0; i--) + { + DownHeap(i); + } + + while (stream.size() > largest) + { + ExtractMin(); + } + } + + int add(int val) + { + + stream.push_back(val); + Upheap(stream.size() - 1); + + while (stream.size() > largest) + { + ExtractMin(); + } + + int kth = stream.front(); + return kth; + } + + void DownHeap(int i) + { + while (2 * i + 1 < stream.size()) + { + int win = 2 * i + 1; + if (2 * i + 2 < stream.size() && stream[2 * i + 2] < stream[2 * i + 1]) + { + win = 2 * i + 2; + } + if (stream[win] < stream[i]) + { + std::swap(stream[win], stream[i]); + i = win; + } + else + { + return; + } + } + } + + void Upheap(int i) + { + while ((i - 1) / 2 >= 0) + { + if (stream[i] < stream[(i - 1) / 2]) + { + std::swap(stream[i], stream[(i - 1) / 2]); + i = (i - 1) / 2; + } + else + { + return; + } + } + } + + void ExtractMin() + { + std::swap(stream[0], stream[stream.size() - 1]); + stream.pop_back(); + DownHeap(0); + } + +private: + vector stream; + int largest; +}; + +/** + * Your KthLargest object will be instantiated and called as such: + * KthLargest* obj = new KthLargest(k, nums); + * int param_1 = obj->add(val); + */ diff --git a/Jongeun/Day14/78_Subsets.cpp b/Jongeun/Day14/78_Subsets.cpp new file mode 100644 index 0000000..6a2d364 --- /dev/null +++ b/Jongeun/Day14/78_Subsets.cpp @@ -0,0 +1,35 @@ +class Solution +{ +public: + vector> subsets(vector &nums) + { + + vector> subsets; + vector subset; + _subset(0, subset, nums, subsets); + + return subsets; + } + + void _subset(int i, vector num, vector &nums, vector> &subsets) + { + if (i == nums.size()) + { + subsets.push_back(num); + return; + } + + for (int j = 0; j < 2; j++) + { + if (j == 0) + { + _subset(i + 1, num, nums, subsets); + } + else + { + num.push_back(nums[i]); + _subset(i + 1, num, nums, subsets); + } + } + } +}; diff --git a/JungHwan/Day12/NeetCode_MaxWaterContainer.py b/JungHwan/Day12/NeetCode_MaxWaterContainer.py index c35e48d..9c55336 100644 --- a/JungHwan/Day12/NeetCode_MaxWaterContainer.py +++ b/JungHwan/Day12/NeetCode_MaxWaterContainer.py @@ -1,9 +1,51 @@ +# 내 처음 답안 class Solution: - def maxArea(self, heights: List[int]) -> int: - max, num = 0, len(heights) - for i in range(num): - for j in range(i+1, num): - h = min(heights[i], heights[j]) - if max < (j - i) * h: - max = (j - i) * h - return max \ No newline at end of file + def largestRectangleArea(self, heights: List[int]) -> int: + l = len(heights) + maxA = 0 + stack = [] # [startIdx, height] + for i in range(l): + if len(stack) == 0: + stack.append([i, heights[i]]) + else: + #append higher height than before + if stack[-1][1] < heights[i]: + stack.append([i, heights[i]]) + #elsewise pop all lower heights + elif stack[-1][1] > heights[i]: + startIdx = 0 + while len(stack) > 0 and stack[-1][1] > heights[i]: + index, height = stack.pop() + startIdx = index + maxA = max(maxA, (i - index) * height) + #now the top is lower than current height, so index starts from after it + stack.append([startIdx, heights[i]]) + else: + continue + print(stack) + + #stack is now in ascending order, with last index l + for index, height in stack: + maxA = max(maxA, (l - index) * height) + return maxA + +# 모범 답안 +class Solution: + def largestRectangleArea(self, heights: List[int]) -> int: + maxArea = 0 + stack = [] # pair: (index, height) + + for i, h in enumerate(heights): + start = i + while stack and stack[-1][1] > h: + index, height = stack.pop() + maxArea = max(maxArea, height * (i - index)) + start = index + stack.append((start, h)) + + for i, h in stack: + maxArea = max(maxArea, h * (len(heights) - i)) + return maxArea + +# 1. len(stack) > 0 판단은 그냥 stack으로 한다. +# 2. 큰 줄기로 보자. stack pop은 더 작은 높이가 등장했을 때이다. append는 생각해보면 높이가 같을 때 수행해도 무방하다. \ No newline at end of file diff --git a/JungHwan/Day18/NeetCode_LargestRectangle.py b/JungHwan/Day18/NeetCode_LargestRectangle.py new file mode 100644 index 0000000..9c55336 --- /dev/null +++ b/JungHwan/Day18/NeetCode_LargestRectangle.py @@ -0,0 +1,51 @@ +# 내 처음 답안 +class Solution: + def largestRectangleArea(self, heights: List[int]) -> int: + l = len(heights) + maxA = 0 + stack = [] # [startIdx, height] + for i in range(l): + if len(stack) == 0: + stack.append([i, heights[i]]) + else: + #append higher height than before + if stack[-1][1] < heights[i]: + stack.append([i, heights[i]]) + #elsewise pop all lower heights + elif stack[-1][1] > heights[i]: + startIdx = 0 + while len(stack) > 0 and stack[-1][1] > heights[i]: + index, height = stack.pop() + startIdx = index + maxA = max(maxA, (i - index) * height) + #now the top is lower than current height, so index starts from after it + stack.append([startIdx, heights[i]]) + else: + continue + print(stack) + + #stack is now in ascending order, with last index l + for index, height in stack: + maxA = max(maxA, (l - index) * height) + return maxA + +# 모범 답안 +class Solution: + def largestRectangleArea(self, heights: List[int]) -> int: + maxArea = 0 + stack = [] # pair: (index, height) + + for i, h in enumerate(heights): + start = i + while stack and stack[-1][1] > h: + index, height = stack.pop() + maxArea = max(maxArea, height * (i - index)) + start = index + stack.append((start, h)) + + for i, h in stack: + maxArea = max(maxArea, h * (len(heights) - i)) + return maxArea + +# 1. len(stack) > 0 판단은 그냥 stack으로 한다. +# 2. 큰 줄기로 보자. stack pop은 더 작은 높이가 등장했을 때이다. append는 생각해보면 높이가 같을 때 수행해도 무방하다. \ No newline at end of file