Merge branch 'DaleStudy:main' into main

Author: Sunjae95

clone-graph/HC-kang.ts

@@ -0,0 +1,63 @@
+/**
+ * https://leetcode.com/problems/clone-graph
+ * T.C. O(N)
+ * S.C. O(N)
+ */
+function cloneGraph(node: _Node | null): _Node | null {
+  if (!node) return null;
+
+  const map = new Map<number, _Node>();
+  return dfs(node);
+
+  function dfs(node: _Node): _Node {
+    if (map.has(node.val)) return map.get(node.val)!;
+
+    const newNode = new _Node(node.val);
+    map.set(node.val, newNode);
+
+    for (let neighbor of node.neighbors) {
+      newNode.neighbors.push(dfs(neighbor));
+    }
+
+    return newNode;
+  }
+}
+
+/**
+ * T.C. O(N)
+ * S.C. O(N)
+ */
+function cloneGraph(node: _Node | null): _Node | null {
+  if (!node) return null;
+
+  const map = new Map<number, _Node>();
+  const stack = [node];
+  const newNode = new _Node(node.val);
+  map.set(node.val, newNode);
+
+  while (stack.length) {
+    const node = stack.pop()!;
+    const newNode = map.get(node.val)!;
+
+    for (let neighbor of node.neighbors) {
+      if (!map.has(neighbor.val)) {
+        stack.push(neighbor);
+        const newNeighbor = new _Node(neighbor.val);
+        map.set(neighbor.val, newNeighbor);
+      }
+      newNode.neighbors.push(map.get(neighbor.val)!);
+    }
+  }
+
+  return newNode;
+}
+
+class _Node {
+  val: number;
+  neighbors: _Node[];
+
+  constructor(val?: number, neighbors?: _Node[]) {
+    this.val = val === undefined ? 0 : val;
+    this.neighbors = neighbors === undefined ? [] : neighbors;
+  }
+}

clone-graph/haklee.py

@@ -0,0 +1,79 @@
+"""TC: O(n + e), SC: -
+
+노드 개수 n개, 엣지 개수 e개
+
+아이디어:
+문제 설명부터가 deepcopy를 하라는 것이니 내장함수를 써서 deepcopy를 해주자.
+
+SC:
+- 내장함수가 필요한 공간들을 따로 잘 관리해주지 않을까? 아마 변수를 읽고 그대로 리턴값으로 바꿔줄듯.
+- 그렇다면 추가적으로 관리하는 공간은 필요 없다.
+
+TC:
+- deepcopy는 필요한 정보를 그대로 다 deepcopy 뜰 뿐이다. 아마 node 개수 + edge 개수에 비례해서 시간이
+  걸릴것 같다. O(n + e).
+"""
+
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+import copy
+from typing import Optional
+
+
+class Solution:
+    def cloneGraph(self, node: Optional["Node"]) -> Optional["Node"]:
+        return copy.deepcopy(node)
+
+
+"""TC: O(e), SC: O(e)
+
+노드 개수 n개, 엣지 개수 e개
+
+아이디어:
+dfs 돌면서 노드들을 메모해두자. neighbors에 특정 노드를 추가해야 할때 메모에 있으면 바로 가져다
+쓰고, 없으면 새로 만들어서 메모에 노드를 추가한다.
+
+SC:
+- 노드 총 n개가 memo에 올라간다. O(n).
+- 각 노드마다 neighbor가 있다. 각 edge마다 neighbor 리스트들의 총 아이템 개수에 2개씩 기여한다. O(e).
+- 더하면 O(n + e). 즉, 둘 중 더 큰 값이 공간복잡도를 지배한다.
+  ...고 생각하는 것이 일차적인 분석인데, 여기서 더 나아갈 수 있다.
+- 주어진 조건에 따르면 우리에게 주어진 그래프는 connected graph다. 즉, 엣지 개수가 n-1개 이상이다.
+- 즉, O(n) < O(e)가 무조건 성립하므로, O(e) < O(n + e) < O(e + e) = O(e). 즉, O(e).
+
+TC:
+- SC와 비슷한 방식으로 분석 가능. O(e).
+"""
+
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+from typing import Optional
+
+
+class Solution:
+    def cloneGraph(self, node: Optional["Node"]) -> Optional["Node"]:
+        if node is None:
+            return node
+
+        memo = {}
+
+        def dfs(node):
+            if node not in memo:
+                new_node = Node(node.val, [])
+                memo[node] = new_node
+                new_node.neighbors = [dfs(i) for i in node.neighbors]
+            return memo[node]
+
+        return dfs(node)

clone-graph/hwanmini.js

@@ -0,0 +1,39 @@
+// 노드 수 v, 간선 e
+// 시간복잡도 O(v+e)
+// 공간복잡도 O(v+e)
+
+/**
+ * // Definition for a _Node.
+ * function _Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ */
+
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function(node) {
+    if (!node) return
+
+    const visited = new Map()
+    visited.set(node, new _Node(node.val))
+
+    const que = [node]
+
+    while (que.length) {
+        const curNode = que.shift()
+
+        for (neighbor of curNode.neighbors) {
+            if (!visited.has(neighbor)) {
+                visited.set(neighbor, new _Node(neighbor.val));
+                que.push(neighbor)
+            }
+
+            visited.get(curNode).neighbors.push(visited.get(neighbor))
+        }
+    }
+
+    return visited.get(node)
+};

clone-graph/jaejeong1.java

@@ -0,0 +1,56 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+
+// Definition for a Node.
+class Node {
+  public int val;
+  public List<Node> neighbors;
+  public Node() {
+    val = 0;
+    neighbors = new ArrayList<Node>();
+  }
+  public Node(int _val) {
+    val = _val;
+    neighbors = new ArrayList<Node>();
+  }
+  public Node(int _val, ArrayList<Node> _neighbors) {
+    val = _val;
+    neighbors = _neighbors;
+  }
+}
+
+
+class Solution {
+  // 풀이: BFS 방식으로 그래프를 순회하면서 현재 노드에 연결된 노드들을 복제 여부에 따라 복제 또는 연결 처리해준다
+  // TC: O(N)
+  // SC: O(N)
+  public Node cloneGraph(Node node) {
+    if (node == null) {
+      return null;
+    }
+
+    Map<Node, Node> cloneMap = new HashMap<>();
+    Node clone = new Node(node.val);
+    cloneMap.put(node, clone);
+
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(node);
+
+    while (!queue.isEmpty()) {
+      Node current = queue.poll();
+
+      for (Node neighbor : current.neighbors) {
+        if (!cloneMap.containsKey(neighbor)) {
+          cloneMap.put(neighbor, new Node(neighbor.val));
+          queue.add(neighbor);
+        }
+        cloneMap.get(current).neighbors.add(cloneMap.get(neighbor));
+      }
+    }
+    return clone;
+  }
+}

clone-graph/kayden.py

@@ -0,0 +1,28 @@
+from typing import Optional
+from collections import deque
+
+
+class Solution:
+    # 시간복잡도: O(N) node 개수: N
+    # 공간복잡도: O(N)
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if node:
+            visited = {}
+            copy = Node(val=node.val)
+            visited[copy.val] = copy
+            q = deque()
+            q.append((copy, node))
+
+            while q:
+                cur, node = q.popleft()
+
+                for idx, next_node in enumerate(node.neighbors):
+                    if next_node.val not in visited:
+                        new = Node(val=next_node.val)
+                        visited[new.val] = new
+                        q.append((new, next_node))
+                    cur.neighbors.append(visited[next_node.val])
+
+            return copy
+
+        return node

clone-graph/wogha95.js

@@ -0,0 +1,74 @@
+/**
+ * TC: O(V + E)
+ * 모든 정점를 방문하게 되고
+ * 방문한 정점에서 연결된 간선을 queue에 추가하는 반복문을 실행합니다.
+ * 따라서 시간복잡도는 정점 + 간선에 선형적으로 비례합니다.
+ *
+ * SC: O(V + E)
+ * memory, visitedNodeVal 에서 V만큼 데이터 공간을 가집니다.
+ * 그리고 queue에서 최대 모든 간선 갯수 * 2 만큼 갖게 됩니다.
+ * 따라서 O(V + 2E) = O(V + E)로 계산했습니다.
+ *
+ * V: vertex, E: edge
+ */
+
+/**
+ * // Definition for a _Node.
+ * function _Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ */
+
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function (node) {
+  if (!node) {
+    return null;
+  }
+
+  const memory = new Map();
+  const visitedNodeVal = new Set();
+
+  return bfsClone(node);
+
+  // 1. bfs로 순회하면서 deep clone한 graph의 head를 반환
+  function bfsClone(start) {
+    const queue = [start];
+    const clonedHeadNode = new _Node(start.val);
+    memory.set(start.val, clonedHeadNode);
+
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visitedNodeVal.has(current.val)) {
+        continue;
+      }
+
+      const clonedCurrentNode = getCloneNode(current.val);
+
+      for (const neighbor of current.neighbors) {
+        const clonedNeighborNode = getCloneNode(neighbor.val);
+        clonedCurrentNode.neighbors.push(clonedNeighborNode);
+
+        queue.push(neighbor);
+      }
+
+      visitedNodeVal.add(current.val);
+    }
+
+    return clonedHeadNode;
+  }
+
+  // 2. memory에 val에 해당하는 node 반환 (없을 경우 생성)
+  function getCloneNode(val) {
+    if (!memory.has(val)) {
+      const node = new _Node(val);
+      memory.set(val, node);
+      return node;
+    }
+
+    return memory.get(val);
+  }
+};

longest-common-subsequence/HC-kang.ts

@@ -0,0 +1,23 @@
+/**
+ * https://leetcode.com/problems/longest-common-subsequence
+ * T.C. O(m * n)
+ * S.C. O(n)
+ */
+function longestCommonSubsequence(text1: string, text2: string): number {
+  const dp = Array.from({ length: text2.length + 1 }, () => 0);
+
+  for (let i = 1; i <= text1.length; i++) {
+    let prev = 0;
+    for (let j = 1; j <= text2.length; j++) {
+      const temp = dp[j];
+      if (text1[i - 1] === text2[j - 1]) {
+        dp[j] = prev + 1;
+      } else {
+        dp[j] = Math.max(dp[j], dp[j - 1]);
+      }
+      prev = temp;
+    }
+  }
+
+  return dp[text2.length];
+}