Merge remote-tracking branch 'upstream/main'

Author: sun912

longest-consecutive-sequence/EGON.py

@@ -0,0 +1,66 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        return self.solveWithDict(nums)
+
+    """
+    Runtime: 486 ms (Beats 40.61%)
+    Time Complexity:
+        - nums 배열 조회하며 연산에 O(n)
+        - 크기가 n인 node_dict.items()을 조회, visited에 의해 각 노드당 한 번만 방문,
+            - visited가 set이므로 갱신 및 확인에 O(1)
+            - 2개 항에 대해 max 연산하므로 O(2)로, 총 O(n)
+        > O(n) + O(n) ~= O(n)
+
+    Memory: 44.62 MB (Beats 5.00%)
+    Space Complexity: O(n)
+        - value가 크기 2짜리 배열이고 key가 최대 n인 dict 변수 사용에 O(2n)
+        - 최대 크기가 n인 visited 사용에 O(n)
+        > O(2n) + O(n) ~= O(n)
+    """
+    def solveWithDict(self, nums: List[int]) -> int:
+        node_dict = {}
+        for num in nums:
+            curr_node = [num, num]
+            if num - 1 in node_dict:
+                prev_node = node_dict[num - 1]
+                curr_node[0] = prev_node[0]
+                prev_node[1] = curr_node[1]
+            if num + 1 in node_dict:
+                post_node = node_dict[num + 1]
+                curr_node[1] = post_node[1]
+                post_node[0] = curr_node[0]
+            node_dict[num] = curr_node
+
+        max_length = 0
+        visited = set()
+        for key, (prev_key, post_key) in node_dict.items():
+            while prev_key not in visited and prev_key in node_dict:
+                visited.add(prev_key)
+                prev_key = node_dict[prev_key][0]
+            while post_key not in visited and post_key in node_dict:
+                visited.add(post_key)
+                post_key = node_dict[post_key][1]
+            curr_length = post_key - prev_key + 1
+            max_length = max(max_length, curr_length)
+
+        return max_length
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        nums = [100, 4, 200, 1, 3, 2]
+        output = 4
+        self.assertEqual(Solution.longestConsecutive(Solution(), nums), output)
+
+    def test_2(self):
+        nums = [0, 3, 7, 2, 5, 8, 4, 6, 0, 1]
+        output = 9
+        self.assertEqual(Solution.longestConsecutive(Solution(), nums), output)
+
+
+if __name__ == '__main__':
+    main()

longest-consecutive-sequence/flynn.cpp

@@ -0,0 +1,37 @@
+/**
+ * 풀이
+ * - 주어진 배열 `nums`로 set `s`를 만듭니다
+ * - `nums`를 조회하는데, 현재 조회 중인 `num`에 대하여 `num - 1`이 `s`에 포함되지 않는 경우만 while문을 실행하여 subsequence의 길이를 측정합니다
+ * - `num - 1`이 `s`에 포함되지 않는다는 것은 `num`이 해당 subsequence의 첫 수임을 뜻합니다
+ * 
+ * Big-O
+ * - N: 주어진 배열 `nums`의 길이
+ * 
+ * - Time complexity: O(N)
+ *   - 이중 반복문의 구조를 가졌지만, 조건문때문에 각 원소를 한 번씩만 조회합니다
+ * 
+ * - Space complexity: O(N)
+ *   - `nums`를 구성하는 원소가 모두 고유한 정수일 경우, `s`의 크기가 `nums`만큼 커질 수 있습니다
+ */
+
+class Solution {
+public:
+    int longestConsecutive(vector<int>& nums) {
+        unordered_set<int> s(nums.begin(), nums.end());
+        
+        int res = 0;
+        for (int num : nums) {
+            if (s.find(num - 1) != s.end()) continue;
+            
+            int curr = num;
+            int streak = 1;
+            while (s.find(curr + 1) != s.end()) {
+                ++curr;
+                ++streak;
+            }
+            res = max(res, streak);
+        }
+
+        return res;
+    }
+};

longest-consecutive-sequence/haklee.py

@@ -0,0 +1,36 @@
+"""TC: O(n), SC: O(n)
+
+아이디어:
+- nums 안에는 여러 consecutive sequence(이하 cs)가 존재할 것이다(길이 1인 것까지 포함).
+- 이 cs는 모두 제일 앞 숫자를 가지고 있다.
+- 제일 앞 숫자는 그 숫자 바로 앞에 숫자가 없다는 특징을 가지고 있다.
+    - 즉, i가 제일 앞 숫자라면 i-1은 nums 안에 없다.
+- nums에서 제일 앞 숫자를 찾은 다음, 이 숫자부터 뒤로 이어지는 cs를 찾아서 길이를 구할 수 있다.
+- cs의 길이 중 제일 긴 것을 찾아서 리턴하면 된다.
+
+SC:
+- set(nums)에서 O(n).
+- 위 set에서 모든 아이템을 돌면서 i-1이 set 안에 포함되지 않는 i를 찾아서 리스트로 만들때 O(n).
+- 총 O(n).
+
+TC:
+- set(nums)에서 O(n).
+- 위 set에서 모든 아이템을 돌면서 i-1이 set 안에 포함되지 않는 i를 찾는 데에 O(n).
+- 각 cs의 제일 앞 숫자부터 이어지는 숫자들이 set 안에 있는지 체크하는 데에 총 O(n).
+- 총 O(n).
+"""
+
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        s = set(nums)  # TC:O(n), SC:O(n)
+        seq_start_candidate = [i for i in s if i - 1 not in s]  # TC:O(n), SC:O(n)
+        sol = 0
+
+        # 아래의 for문 내에서는 s에 속한 아이템에 한 번씩 접근한다. TC:O(n)
+        for i in seq_start_candidate:
+            seq_len = 1
+            while i + seq_len in s:
+                seq_len += 1
+            sol = max(seq_len, sol)
+        return sol

longest-consecutive-sequence/heozeop.cpp

@@ -0,0 +1,25 @@
+// time complexity: O(n)
+// spatail complexity: O(n)
+
+class Solution {
+public:
+    int longestConsecutive(vector<int>& nums) {
+        unordered_set<int> exisingNum(nums.begin(), nums.end());
+
+        int maxLength = 0, length;
+        for(int num : nums) {
+            if(exisingNum.find(num - 1) != exisingNum.end()) {
+                continue;
+            }
+
+            length = 1;
+            while(exisingNum.find(num + length) != exisingNum.end()) {
+                ++length;
+            }
+
+            maxLength = max(maxLength, length);
+        }
+
+        return maxLength;
+    }
+};

longest-consecutive-sequence/hwanmini.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function(nums) {
+    if (nums.length === 0) return 0;
+
+    const numSet = new Set(nums);
+    let maxSequenceLength = 0;
+
+    for (const num of numSet) {
+        if (!numSet.has(num - 1)) {
+            let currentNum = num;
+            let currentLength = 1;
+
+            while (numSet.has(currentNum + 1)) {
+                currentNum++;
+                currentLength++;
+            }
+
+            maxSequenceLength = Math.max(maxSequenceLength, currentLength);
+        }
+    }
+
+    return maxSequenceLength;
+};
+
+console.log(longestConsecutive([100, 4, 200, 1, 3, 2]));
+console.log(longestConsecutive([0, 3, 7, 2, 5, 8, 4, 6, 0, 1]));

longest-consecutive-sequence/sunjae95.js

@@ -0,0 +1,114 @@
+/**
+ * @description
+ * brainstorming:
+ * priority queue + result counting that priority queue was pop
+ *
+ * time complexity: O(n log n)
+ * space complexity: O(n)
+ */
+var longestConsecutive = function (nums) {
+  const queue = new CustomQueue();
+  let [count, before, answer] = [0, null, 0];
+
+  nums.forEach((n) => queue.insert(n));
+
+  if (queue.size === 0) return count;
+
+  [count, before, answer] = [1, queue.remove(), 1];
+
+  while (queue.size) {
+    const current = queue.remove();
+
+    if (before === current) continue;
+
+    count = before + 1 === current ? count + 1 : 1;
+    before = current;
+    answer = Math.max(answer, count);
+  }
+
+  return answer;
+};
+
+class Node {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class CustomQueue {
+  constructor() {
+    this.items = new Map();
+    this.size = 0;
+  }
+
+  parentIndex(index) {
+    return Math.floor((index - 1) / 2);
+  }
+
+  leftChildIndex(index) {
+    return 2 * index + 1;
+  }
+
+  rightChildIndex(index) {
+    return 2 * index + 2;
+  }
+
+  heapifyUp() {
+    let index = this.size - 1;
+
+    while (index > 0) {
+      const parentIndex = this.parentIndex(index);
+      const parent = this.items.get(parentIndex);
+      const current = this.items.get(index);
+
+      if (parent.value <= current.value) break;
+
+      this.items.set(this.parentIndex(index), current);
+      this.items.set(index, parent);
+
+      index = parentIndex;
+    }
+  }
+
+  heapifyDown() {
+    let index = 0;
+
+    while (this.leftChildIndex(index) < this.items.size) {
+      let smallestIndex = this.leftChildIndex(index);
+      let rightIndex = this.rightChildIndex(index);
+      const current = this.items.get(index);
+
+      if (
+        rightIndex < this.size &&
+        this.items.get(rightIndex).value < this.items.get(smallestIndex).value
+      ) {
+        smallestIndex = rightIndex;
+      }
+
+      if (current.value <= this.items.get(smallestIndex).value) break;
+      this.items.set(index, this.items.get(smallestIndex));
+      this.items.set(smallestIndex, current);
+      index = smallestIndex;
+    }
+  }
+
+  insert(value) {
+    const index = this.size;
+    const node = new Node(value);
+    this.items.set(index, node);
+    this.size++;
+    this.heapifyUp();
+  }
+
+  remove() {
+    if (this.size === 0) return null;
+
+    const root = this.items.get(0);
+    this.items.set(0, this.items.get(this.size - 1));
+    this.items.delete(this.size - 1);
+    this.size--;
+
+    this.heapifyDown();
+    return root.value;
+  }
+}

longest-consecutive-sequence/whewchews.ts

@@ -0,0 +1,61 @@
+/*
+* 조건
+* 연속된 수가 가장 긴 경우, 몇 번인지 구하기. 같은 값은 이어서 연결할 수 있음.
+* 시간복잡도는 O(n)이어야함 = nums 배열을 한번만 돌아서 구할 것, 정렬 메소드는 쓸 수 없음(O(nlogn))
+*
+* 아이디어
+* 시작지점과 끝나는 지점, 그 길이가 가장 긴 것을 구해야함
+* 배열 값들을 한번만 체크할 수 있도록 배열을 돌면서 값을 set 자료구조에 저장해둔다
+* 이때 set 사용하는 이유는, 
+* 특정 값이 중복인 경우를 고려할 필요가 없기 때문
+* 
+* 다시 nums 배열을 돌면서 현재 값 직전값이나 이후값이 있는지, 앞뒤로 연속되는 수가 몇개가 있는지 체크한다
+* 앞뒤로 연속되는 숫자의 개수로 새로운 배열을 만든다
+* 새로 만들어진 배열 중 가장 큰 값을 리턴한다
+
+* 이렇게 했을때 leetcode 시간초과가 뜬다.
+* 중복계산 하는 부분을 줄여보자.
+* 왼쪽에 있는 값은 왼쪽값에서 체크를 할거라 미리 계산해줄 필요가 없다, 현재 값부터 오른쪽 값만 계산한다.
+* nums 배열을 돌면서 왼쪽값이 없는 경우만 오른쪽 값에 대해 길이를 계산한다
+* 값에 대한 오른쪽 길이를 이미 계산한 적 있는 경우, memo된 값을 사용한다
+* 
+*/
+function longestConsecutive(nums: number[]): number {
+  // TC: O(n)
+  // SC: O(n)
+  const numSet: Set<number> = new Set(nums);
+
+  // SC: O(n)
+  const numLengthMemo: Map<number, number> = new Map();
+  let maxLength = 0;
+
+  // TC: O(n)
+  for (let n of nums) {
+    if (!numSet.has(n - 1)) {
+      let length = 1;
+
+      if (numLengthMemo.has(n)) {
+        length = numLengthMemo.get(n);
+        maxLength = Math.max(maxLength, length);
+        continue;
+      }
+
+      // TC: O(n)
+      while (numSet.has(n + length)) {
+        length++;
+      }
+
+      numLengthMemo.set(n, length);
+      maxLength = Math.max(maxLength, length);
+    }
+  }
+
+  return maxLength;
+}
+
+function getNumCount(current: number, dict: Map<number, number>) {
+  return dict.get(current) ?? 0;
+}
+
+// TC: O(n)
+// SC: O(n)