Merge branch 'DaleStudy:main' into main

Author: rivkode

coin-change/Chaedie.py

@@ -0,0 +1,28 @@
+"""
+직접 풀지 못해 알고달레 풀이를 참고했습니다. https://www.algodale.com/problems/coin-change/
+
+Solution:
+    1) BFS를 통해 모든 동전을 한번씩 넣어보며 amount와 같아지면 return
+
+(c: coins의 종류 갯수, a: amount)
+Time: O(ca)
+Space: O(a)
+"""
+
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        q = deque([(0, 0)])  # (동전 갯수, 누적 금액)
+        visited = set()
+
+        while q:
+            count, total = q.popleft()
+            if total == amount:
+                return count
+            if total in visited:
+                continue
+            visited.add(total)
+            for coin in coins:
+                if total + coin <= amount:
+                    q.append((count + 1, total + coin))
+        return -1

coin-change/gwbaik9717.js

@@ -0,0 +1,23 @@
+// n: amount m: length of coins
+// Time complexity: O(n * m) + O(mlogm)
+// Space complexity: O(n)
+
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ */
+var coinChange = function (coins, amount) {
+  const dp = Array.from({ length: amount + 1 }, () => Infinity);
+  dp[0] = 0;
+
+  coins.sort((a, b) => a - b);
+
+  for (const coin of coins) {
+    for (let i = coin; i <= amount; i++) {
+      dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+    }
+  }
+
+  return dp.at(-1) === Infinity ? -1 : dp.at(-1);
+};

coin-change/jinah92.py

@@ -0,0 +1,10 @@
+# O(C*A) times, O(A) spaces
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+       dp = [0] + [amount + 1] * amount
+
+       for coin in coins:
+            for i in range(coin, amount + 1):
+                dp[i] = min(dp[i], dp[i-coin]+1)
+
+       return dp[amount] if dp[amount] < amount + 1 else -1

coin-change/minji-go.java

@@ -0,0 +1,23 @@
+/*
+    Problem: https://leetcode.com/problems/coin-change/
+    Description: return the fewest number of coins that you need to make up that amount
+    Concept: Array, Dynamic Programming, Breadth-First Search
+    Time Complexity: O(NM), Runtime 15ms   - M is the amount
+    Space Complexity: O(M), Memory 44.28MB
+*/
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        int[] dp = new int[amount+1];
+        Arrays.fill(dp, amount+1);
+        dp[0]=0;
+
+        for(int i=1; i<=amount; i++){
+            for(int coin : coins){
+                if(i >= coin) {
+                    dp[i] = Math.min(dp[i], dp[i-coin] +1);
+                }
+            }
+        }
+        return dp[amount]>amount? -1: dp[amount];
+    }
+}

coin-change/mmyeon.ts

@@ -0,0 +1,27 @@
+/**
+ *
+ * 접근 방법 :
+ * - 동전 최소 개수 구하는 문제니까 DP로 풀기
+ * - 코인마다 순회하면서 동전 개수 최소값 구하기
+ * - 기존값과 코인을 뺀 값 + 1 중 작은 값으로 업데이트
+ *
+ * 시간복잡도 : O(n * m)
+ * - 코인 개수 n만큼 순회
+ * - 각 코인마다 amount 값(m) 될 때까지 순회
+ *
+ * 공간복잡도 : O(m)
+ * - amount 만큼 dp 배열 생성
+ *
+ */
+function coinChange(coins: number[], amount: number): number {
+  const dp = Array(amount + 1).fill(Number.MAX_VALUE);
+  dp[0] = 0;
+
+  for (const coin of coins) {
+    for (let i = coin; i <= amount; i++) {
+      dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+    }
+  }
+
+  return dp[amount] === Number.MAX_VALUE ? -1 : dp[amount];
+}

coin-change/pmjuu.py

@@ -0,0 +1,25 @@
+from typing import List
+
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+         # dp[i]: i 금액을 만들기 위해 필요한 최소 동전 개수
+        dp = [float('inf')] * (amount + 1)
+        dp[0] = 0
+
+        for i in range(1, amount + 1):
+            for coin in coins:
+                if coin <= i:
+                    dp[i] = min(dp[i], dp[i - coin] + 1)
+
+        return dp[amount] if dp[amount] != float('inf') else -1
+
+
+# 시간 복잡도:
+# - 외부 반복문은 금액(amount)의 범위에 비례하고 -> O(n) (n은 amount)
+# - 내부 반복문은 동전의 개수에 비례하므로 -> O(m) (m은 coins의 길이)
+# - 총 시간 복잡도: O(n * m)
+
+# 공간 복잡도:
+# - dp 배열은 금액(amount)의 크기만큼의 공간을 사용하므로 O(n)
+# - 추가 공간 사용은 없으므로 총 공간 복잡도: O(n)

combination-sum/minji-go.java

@@ -2,10 +2,8 @@
     Problem: https://leetcode.com/problems/combination-sum/
     Description: return a list of all unique combinations of candidates where the chosen numbers sum to target
     Concept: Array, Backtracking
-    Time Complexity: O(Nⁿ), Runtime 2ms
-    Space Complexity: O(N), Memory 44.88MB
-
-    - Time Complexity, Space Complexity를 어떻게 계산해야할지 어렵네요 :(
+    Time Complexity: O(Nᵀ), Runtime 2ms 
+    Space Complexity: O(T), Memory 44.88MB
 */
 class Solution {
     public List<List<Integer>> answer = new ArrayList<>();

merge-two-sorted-lists/Chaedie.py

@@ -0,0 +1,36 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def mergeTwoLists(
+        self, list1: Optional[ListNode], list2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+        """
+        Solution:
+            1) 리스트1 리스트2가 null 이 아닌 동안 list1, list2를 차례대로 줄세운다.
+            2) list1이 남으면 node.next = list1로 남은 리스트를 연결한다.
+            3) list2가 남으면 list2 를 연결한다.
+
+        Time: O(n)
+        Space: O(1)
+        """
+        dummy = ListNode()
+        node = dummy
+
+        while list1 and list2:
+            if list1.val < list2.val:
+                node.next = list1
+                list1 = list1.next
+            else:
+                node.next = list2
+                list2 = list2.next
+            node = node.next
+
+        if list1:
+            node.next = list1
+        elif list2:
+            node.next = list2
+
+        return dummy.next

merge-two-sorted-lists/anniemon.js

@@ -0,0 +1,39 @@
+/**
+ * 시간 복잡도:
+ *   list1의 길이가 m, list2의 길이가 n이면
+ *   포인터가 최대 m + n만큼 순회하므로 O(m + n)
+ * 공간 복잡도:
+ *   포인터를 사용하므로 O(1)
+ */
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} list1
+ * @param {ListNode} list2
+ * @return {ListNode}
+ */
+var mergeTwoLists = function(list1, list2) {
+  const head = new ListNode(0, null);
+  let pointer = head;
+  while(list1 && list2) {
+      if(list1.val < list2.val) {
+          pointer.next = list1;
+          list1 = list1.next;
+      } else {
+          pointer.next = list2;
+          list2 = list2.next;
+      }
+      pointer = pointer.next;
+  }
+  if(list1) {
+      pointer.next = list1;
+  } else {
+      pointer.next = list2;
+  }
+  return head.next;
+};

merge-two-sorted-lists/bus710.go

@@ -0,0 +1,52 @@
+package hello
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode {
+	if list1 == nil && list2 == nil {
+		return nil
+	} else if list1 == nil {
+		return list2
+	} else if list2 == nil {
+		return list1
+	}
+
+	newList := &ListNode{}
+	cur := newList
+
+	for {
+		switch {
+		case list1.Val < list2.Val:
+			cur.Next = &ListNode{Val: list1.Val}
+			list1 = list1.Next
+		case list1.Val > list2.Val:
+			cur.Next = &ListNode{Val: list2.Val}
+			list2 = list2.Next
+		default:
+			cur.Next = &ListNode{Val: list1.Val}
+			list1 = list1.Next
+			cur = cur.Next
+			cur.Next = &ListNode{Val: list2.Val}
+			list2 = list2.Next
+		}
+		cur = cur.Next
+		if list1 == nil && list2 == nil && cur.Next == nil {
+			break
+		}
+
+		if list1 == nil {
+			cur.Next = list2
+			break
+		}
+		if list2 == nil {
+			cur.Next = list1
+			break
+		}
+
+	}
+
+	return newList.Next
+}

merge-two-sorted-lists/gwbaik9717.js

@@ -0,0 +1,42 @@
+// m: list1, n: list2
+// Time complexity: O(m+n)
+// Space complexity: O(m+n)
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} list1
+ * @param {ListNode} list2
+ * @return {ListNode}
+ */
+var mergeTwoLists = function (list1, list2) {
+  const answer = new ListNode();
+  let current = answer;
+
+  while (list1 && list2) {
+    if (list1.val < list2.val) {
+      current.next = list1;
+      list1 = list1.next;
+    } else {
+      current.next = list2;
+      list2 = list2.next;
+    }
+
+    current = current.next;
+  }
+
+  if (list1) {
+    current.next = list1;
+  }
+
+  if (list2) {
+    current.next = list2;
+  }
+
+  return answer.next;
+};

merge-two-sorted-lists/jinah92.py

@@ -0,0 +1,18 @@
+# O(m+n) times, O(1) spaces
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        dummy = ListNode(None)
+        node = dummy
+
+        while list1 and list2:
+            if list1.val < list2.val:
+                node.next = list1
+                list1 = list1.next
+            else:
+                node.next = list2
+                list2 = list2.next
+
+            node = node.next
+        
+        node.next = list1 or list2
+        return dummy.next

merge-two-sorted-lists/minji-go.java

@@ -0,0 +1,36 @@
+/*
+    Problem: https://leetcode.com/problems/merge-two-sorted-lists/
+    Description: return the head of the merged linked list of two sorted linked lists
+    Concept: Linked List, Recursion
+    Time Complexity: O(N+M), Runtime 0ms
+    Space Complexity: O(N+M), Memory 42.74MB
+*/
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+
+        ListNode head = new ListNode(0);
+        ListNode tail = head;
+
+        while(list1 != null || list2 != null) {
+            if (list2 == null || (list1 != null && list1.val <= list2.val)) {
+                tail = tail.next = new ListNode(list1.val);
+                list1 = list1.next;
+            } else {
+                tail = tail.next = new ListNode(list2.val);
+                list2 = list2.next;
+            }
+        }
+        return head.next;
+    }
+}