Merge branch 'DaleStudy:main' into main

Author: Yjason-K

clone-graph/Chaedie.py

@@ -0,0 +1,32 @@
+"""
+한번에 풀지 못해 다시 풀어볼 예정입니다.
+
+Solution:
+    1) oldToNew 라는 dict 를 만들어 무한루프를 방지합니다.
+    2) newNode = Node(node.val), newNode.neighbors.append(dfs(nei)) 를 통해 clone을 구현합니다.
+
+정점 V, 간선 E
+Time: O(V + E)
+Space: O(V + E)
+"""
+
+
+class Solution:
+    def cloneGraph(self, root: Optional["Node"]) -> Optional["Node"]:
+        if not root:
+            return None
+        oldToNew = {}
+
+        def dfs(node):
+            if node in oldToNew:
+                return oldToNew[node]
+
+            newNode = Node(node.val)
+            oldToNew[node] = newNode
+
+            for nei in node.neighbors:
+                newNode.neighbors.append(dfs(nei))
+
+            return newNode
+
+        return dfs(root)

clone-graph/EcoFriendlyAppleSu.kt

@@ -0,0 +1,47 @@
+package leetcode_study
+
+/*
+* Graph Node 복사 문제
+* queue를 사용해 문제 해결
+* 새로 생성한 Node에 대해 방문처리를 하지 않을 경우 무한 Loop에 빠지게됨 -> 각 노드가 양방향을 가리키고 있기 때문.
+* 따라서, Map 자료구조를 사용해 Map<기존 Node, 복사 Node>의 모습으로 Key-Value 쌍으로 방문처리를 표현
+*
+* 시간 복잡도: O(n)
+* -> graph의 Node를 한 번씩 방문하여 복사하는 과정: O(n)
+* 공간 복잡도:
+* -> 복사된 Node를 매핑하는 Map 자료구조의 크기: O(n)
+* -> BFS를 사용한 queue size: O(n)
+* -> 새로 생성된 Node의 neighbor list: O(n)
+* */
+fun cloneGraph(node: Node?): Node? {
+    if (node == null) return null
+    if (node.neighbors.isEmpty()) return Node(1)
+
+    // Map< 기존 Node, 복사 Node>
+    val nodeMap = mutableMapOf<Node, Node>()
+
+    val queue = ArrayDeque<Node>()
+    queue.add(node)
+    nodeMap[node] = Node(node.`val`)
+
+    while (queue.isNotEmpty()) {
+        val current = queue.removeFirst()
+        val clonedNode = nodeMap[current]!! // 현재 노드의 복제본
+
+        for (neighbor in current.neighbors) {
+            if (neighbor == null) continue
+
+            // 해당 이웃이 아직 복사되지 않았다면 복사하여 맵에 저장하고 큐에 추가
+            if (!nodeMap.containsKey(neighbor)) {
+                nodeMap[neighbor] = Node(neighbor.`val`)
+                queue.add(neighbor)
+            }
+
+            // 복제된 현재 노드의 이웃 리스트에 복제된 이웃 노드를 추가
+            // 양방향을 따질 필요 없이 내부 neighbor node list에 모든 노드가 있음
+            clonedNode.neighbors.add(nodeMap[neighbor])
+        }
+    }
+    return nodeMap[node]
+}
+

clone-graph/dusunax.py

@@ -0,0 +1,35 @@
+'''
+# 133. Clone Graph
+This is the problem for copying nodes, which helps you understand the concept of referencing a node & copying the node (creating a new node from the existing one).
+
+👉 Perform recursion DFS with the correct escape condition and handling of NoneType.
+'''
+
+"""
+# 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 None
+            
+        visited = {}
+        
+        def DFS(currNode):
+            if currNode.val in visited:
+                return visited[currNode.val]
+
+            copiedNode = Node(currNode.val)
+            visited[currNode.val] = copiedNode
+
+            for neighbor in currNode.neighbors:
+                copiedNode.neighbors.append(DFS(neighbor))
+
+            return copiedNode
+
+        return DFS(node)

clone-graph/ekgns33.java

@@ -0,0 +1,42 @@
+/*
+// 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 {
+  public Node cloneGraph(Node node) {
+    Map<Integer, Node> nodeMap = new HashMap<>();
+    if(node == null) return null;
+    boolean[] visited = new boolean[101];
+    dfsHelper(nodeMap, node, visited);
+    return nodeMap.get(1);
+  }
+
+  private void dfsHelper(Map<Integer, Node> map, Node node, boolean[] visited) {
+    if(!map.containsKey(node.val)) {
+      map.put(node.val, new Node(node.val));
+    }
+    visited[node.val] = true;
+    Node cur = map.get(node.val);
+    for(Node adjacent : node.neighbors) {
+      map.putIfAbsent(adjacent.val, new Node(adjacent.val));
+      cur.neighbors.add(map.get(adjacent.val));
+      if(!visited[adjacent.val]) dfsHelper(map, adjacent, visited);
+    }
+  }
+}

clone-graph/imsosleepy.java

@@ -0,0 +1,22 @@
+// 문제 의도를 잘 모르겠음. 깊은 복사가 된 Node를 만들면 된다.
+// DFS로 풀면 되고, BFS도 가능하겠지만 BFS는 까딱 잘못하면 타임아웃이 나서 그냥 DFS로 해결
+class Solution {
+    private Map<Node, Node> visited = new HashMap<>();
+
+    public Node cloneGraph(Node node) {
+        if (node == null) return null;
+
+        if (visited.containsKey(node)) {
+            return visited.get(node);
+        }
+
+        Node cloneNode = new Node(node.val);
+        visited.put(node, cloneNode);
+
+        for (Node neighbor : node.neighbors) {
+            cloneNode.neighbors.add(cloneGraph(neighbor));
+        }
+
+        return cloneNode;
+    }
+}

clone-graph/pmjuu.py

@@ -0,0 +1,40 @@
+'''
+시간 복잡도: O(V + E)
+- 그래프의 모든 노드를 한 번씩 방문해야 하므로 O(V)
+- 각 노드의 모든 간선을 한 번씩 탐색해야 하므로 O(E)
+- 따라서 전체 시간 복잡도는 O(V + E)
+
+공간 복잡도: O(V + E)
+- 클론 노드를 저장하는 딕셔너리(clones): O(V)
+- BFS 탐색을 위한 큐(queue): O(V)
+- 복제된 그래프의 노드와 간선 저장 공간: O(V + E)
+'''
+
+from typing import Optional
+from collections import deque
+# 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 []
+
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return None
+
+        clones = { node.val: Node(node.val) }
+        queue = deque([node])
+
+        while queue:
+            current_node = queue.popleft()
+
+            for neighbor in current_node.neighbors:
+                # add neighbors
+                if neighbor.val not in clones.keys():
+                    queue.append(neighbor)
+                    clones[neighbor.val] = Node(neighbor.val)
+                    
+                clones[current_node.val].neighbors.append(clones[neighbor.val])
+        
+        return clones[node.val]

clone-graph/sungjinwi.py

@@ -0,0 +1,44 @@
+"""
+    풀이 :
+        재귀를 이용해서 dfs풀이
+        node를 복제하고 노드의 이웃된 노드에 대해서 재귀함수 호출을 통해 완성한다
+
+        clones 딕셔너리에 이미 복사된 node들을 저장해서 이미 복제된 node에 대해
+        함수를 호출하면 바로 return
+
+    노드의 수 : V(정점 : Vertex) 이웃의 수 : E(간선 : Edge)라고 할 때
+
+    TC : O(V + E)
+        노드와 이웃에 대해서 순회하므로
+
+    SC : O(V + E)
+        해시테이블의 크기가 노드의 수에 비례해서 커지고 
+        dfs의 호출스택은 이웃의 수만큼 쌓이므로
+"""
+
+"""
+# 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 not node :
+            return None
+
+        clones = {}
+        
+        def dfs(node : Optional['Node']) -> Optional['Node']:
+            if node in clones :
+                return clones[node]
+            clone = Node(node.val)
+            clones[node] = clone
+            for nei in node.neighbors :
+                clone.neighbors.append(dfs(nei))
+            return clone
+
+        return dfs(node)

clone-graph/yolophg.py

@@ -0,0 +1,28 @@
+# Time Complexity: O(N + E) - visit each node once and for each node, we iterate through its neighbors O(E).
+# Space Complexity: O(N) - store a copy of each node in the hashmap O(N).
+
+class Solution:
+    def cloneGraph(self, node):
+        if node is None:
+            return None
+    
+        # dictionary to keep track of cloned nodes (original -> clone)
+        mp = {} 
+
+        def clone(node):
+            if node in mp:
+                # if the node has already been cloned, return the copy
+                return mp[node]  
+
+            # create a new node with the same value
+            cpy = Node(node.val)  
+            # store it in the map so don't clone it again
+            mp[node] = cpy  
+
+            # clone all neighbors and add them to the new node's neighbors list
+            for n in node.neighbors:
+                cpy.neighbors.append(clone(n))
+
+            return cpy
+
+        return clone(node)

find-minimum-in-rotated-sorted-array/KwonNayeon.py

@@ -0,0 +1,42 @@
+"""
+Constraints:
+- n == nums.length
+- 1 <= n <= 5000
+- -5000 <= nums[i] <= 5000
+- All the integers of nums are unique.
+- nums is sorted and rotated between 1 and n times.
+
+Time Complexity: O(log n) 
+- 이진 탐색을 사용하므로 매 단계마다 탐색 범위가 절반으로 줄어듦
+
+Space Complexity: O(1)
+- 추가 공간을 사용하지 않고 포인터만 사용
+
+풀이방법:
+1. 이진 탐색(Binary Search) 활용
+2. mid와 right 값을 비교하여 조건을 나눔
+  - Case 1: nums[mid] > nums[right]
+    - 오른쪽 부분이 정렬되어 있지 않음
+    - 최솟값은 mid 오른쪽에 존재
+    - left = mid + 1
+  - Case 2: nums[mid] <= nums[right]
+    - mid부터 right까지는 정렬되어 있음
+    - 최솟값은 mid를 포함한 왼쪽에 존재 가능
+    - right = mid
+"""
+
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        left = 0
+        right = len(nums) - 1
+
+        while left < right:
+            mid = (left + right) // 2
+
+            if nums[mid] > nums[right]:
+                left = mid + 1
+            
+            else:
+                right = mid
+        
+        return nums[left]

find-minimum-in-rotated-sorted-array/gwbaik9717.js

@@ -0,0 +1,32 @@
+// Time complexity: O(logn)
+// Space complexity: O(1)
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function (nums) {
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+
+    if (nums.at(mid - 1) > nums.at(mid)) {
+      return nums[mid];
+    }
+
+    if (nums.at(mid + 1) < nums.at(mid)) {
+      return nums[mid + 1];
+    }
+
+    if (nums.at(mid + 1) > nums.at(right)) {
+      left = mid + 1;
+      continue;
+    }
+
+    right = mid - 1;
+  }
+
+  return nums[left];
+};

find-minimum-in-rotated-sorted-array/jdy8739.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function (nums) {
+    while (1 < nums.length) {
+
+        const mid = Math.floor(nums.length / 2);
+
+        const firstToHalf = [...nums].slice(0, mid);
+
+        const midToEnd = [...nums].slice(mid, nums.length);
+
+        const isInFront = Math.min(...firstToHalf) < Math.min(...midToEnd);
+
+        nums = isInFront ? firstToHalf : midToEnd;
+    }
+
+    return nums[0];
+};
+
+// 시간복잡도 0(logn) -> 이진탐색을 통해 배열 nums를 반으로 쪼개가며 해답을 찾기때문에 
+// 공간복잡도 O(n) -> 처음 while문이 돌 때, nums를 쪼갠 두 배열 총 길이의 합은 nums의 처음 길이와 같기때문에