Merge branch 'DaleStudy:main' into main

Author: radiantchoi

coin-change/kimjunyoung90.java

@@ -0,0 +1,28 @@
+import java.util.Arrays;
+
+class Solution {
+    //풀이 원리 = 특정 금액을 만들 때 최소 동전 수는 몇 개?
+    //예) 0원은 동전 0개
+    // 1원은 동전 1개
+    // 2원은 동전 1
+    public int coinChange(int[] coins, int amount) {
+        //불가능한 값
+        int max = amount + 1;
+        int[] dp = new int[amount + 1];
+        //최소 동전 수를 모두 불가능한 값으로 설정
+        Arrays.fill(dp, max);
+        dp[0] = 0;
+
+        //금액 1원 부터 계산
+        for (int i = 1; i <= amount; i++) {
+            //사용할 수 있는 동전을 꺼냄
+            for(int coin: coins) {
+                if (coin <= i) {
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+
+        return dp[amount] > amount ? -1 : dp[amount];
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function(nums) {
+    return Math.min(...nums)
+};

find-minimum-in-rotated-sorted-array/kimjunyoung90.java

@@ -0,0 +1,18 @@
+// 요구사항 : 이진 탐색 이용
+class Solution {
+    public int findMin(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+        while(left < right) {
+            int mid = (left + right) / 2;
+            //중앙 값이 오른쪽 값보다 크다. = 최소값이 오른쪽 구간에 있음
+            if(nums[mid] > nums[right]) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+
+        return nums[left];
+    }
+}

maximum-depth-of-binary-tree/hozzijeong.js

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxDepth = function(root) {
+    if(!root) return 0
+
+    const dfs = (node, level) =>{
+        if(!node) return level;
+
+        let left = level;
+        let right = level
+
+        if(node.left){
+            left = dfs(node.left, level+1)
+        }
+
+        if(node.right){
+            right = dfs(node.right, level+1)
+        }
+
+        return Math.max(left,right);
+    }
+
+    return dfs(root,1)
+};

maximum-depth-of-binary-tree/socow.py

@@ -0,0 +1,46 @@
+
+class Solution:
+    def maxDepth(self, root: Optional['TreeNode']) -> int:
+        """
+        문제
+        - 이진트리의 최대 깊이를 구하라.
+
+        아이디어 (재귀 DFS)
+        - 공집합(None)의 깊이는 0
+        - 현재 노드 깊이 = max(왼쪽 서브트리 깊이, 오른쪽 서브트리 깊이) + 1
+
+        시간복잡도: O(n)  — 각 노드를 한 번씩 방문
+        공간복잡도: O(h)  — 재귀 스택(h는 트리 높이; 최악 O(n), 평균 O(log n))
+        """
+        # 1) 빈 트리이면 깊이 0
+        if not root:
+            return 0
+
+        # 2) 왼쪽/오른쪽 서브트리의 최대 깊이를 구한다
+        left_depth = self.maxDepth(root.left)
+        right_depth = self.maxDepth(root.right)
+
+        # 3) 현재 노드의 깊이 = 더 큰 서브트리 깊이 + 1(현재 노드 포함)
+        return max(left_depth, right_depth) + 1
+# dfs(3) - 왼쪽으로 이동
+# dfs(9) - 왼쪽으로 이동
+# dfs(None) -> 0
+# dfs(9) - 오른쪽으로 이동
+# dfs(None) -> 0
+# dfs(9) 반환: max(0,0)+1 = 1
+# dfs(3) - 오른쪽으로 이동
+# dfs(20) - 왼쪽으로 이동
+# dfs(15) - 왼쪽으로 이동
+# dfs(None) -> 0
+# dfs(15) - 오른쪽으로 이동
+# dfs(None) -> 0
+# dfs(15) 반환: max(0,0)+1 = 1
+# dfs(20) - 오른쪽으로 이동
+# dfs(7) - 왼쪽으로 이동
+# dfs(None) -> 0
+# dfs(7) - 오른쪽으로 이동
+# dfs(None) -> 0
+# dfs(7) 반환: max(0,0)+1 = 1
+# dfs(20) 반환: max(1,1)+1 = 2
+# dfs(3) 반환: max(1,2)+1 = 3
+# 최종 결과: 3

merge-two-sorted-lists/hjeomdev.java

@@ -0,0 +1,28 @@
+/**
+ * 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 list = new ListNode(-1);
+        ListNode result = list;
+        while (list1 != null && list2 != null) {
+            if (list1.val < list2.val) {
+                result.next = list1;
+                list1 = list1.next;
+            } else {
+                result.next = list2;
+                list2 = list2.next;
+            }
+            result = result.next;
+        }
+        result.next = list1 != null ? list1 : list2;
+        return list.next;
+    }
+}

merge-two-sorted-lists/hozzijeong.js

@@ -0,0 +1,32 @@
+/**
+ * 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}
+ */
+
+/**
+  * list는 오름 차순으로 정렬되어 있기 때문에 두 개의 리스트의 head가 더 작은 값이 listNode의 next에 순서대로 들어오게 하면 됩니다.
+  * list 둘 중하나가 없는 경우에는 나머지 다른 하나의 리스트를 반환합니다.
+  * 두 헤드 중에서 더 작은 값의 next에 재귀적으로 다음 링크드 리스트를 넘겨주면서 비교하는 방법으로 문제를 해결했습니다
+  *
+*/
+
+var mergeTwoLists = function(list1, list2) {
+    if(!list1 || !list2) return list1 || list2
+
+    if(list1.val < list2.val){
+        list1.next = mergeTwoLists(list1.next,list2)
+        return list1
+    }
+
+    list2.next = mergeTwoLists(list2.next,list1);
+
+    return list2;
+};

merge-two-sorted-lists/socow.py

@@ -0,0 +1,35 @@
+"""
+        문제 요약
+        - 정렬된 두 연결 리스트를 하나의 정렬된 리스트로 병합
+
+        아이디어
+        - dummy 노드로 시작점 고정
+        - 두 리스트 비교하며 작은 값을 연결
+        - 남은 리스트 한번에 연결
+
+        시간복잡도: O(n + m) - 두 리스트 길이의 합
+        공간복잡도: O(1) - 추가 공간 없이 포인터만 변경
+"""
+
+
+class Solution:
+    def mergeTwoLists(
+        self, list1: Optional[ListNode], list2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+        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
+
+        # 남은 리스트 연결
+        node.next = list1 or list2
+
+        return dummy.next

product-of-array-except-self/ymir0804.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int [] result = new int [nums.length];
+        result[0] = 1;
+        for (int i = 1; i < nums.length; i++) {
+            result[i] = result[i - 1] * nums[i - 1];
+        }
+        int suffixProduct = 1;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            result[i] *= suffixProduct;
+            suffixProduct *= nums[i];
+        }
+        return result;
+    }
+}
+

word-search/kimjunyoung90.java

@@ -0,0 +1,42 @@
+class Solution {
+    public boolean exist(char[][] board, String word) {
+
+        int rows = board.length;
+        int columns = board[0].length;
+        boolean[][] visited = new boolean[rows][columns];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < columns; j++) {
+                if (dfs(board, word, i, j, 0, visited)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean dfs(char[][] board, String word, int row, int col, int idx, boolean[][] visited) {
+        //예외 처리 1
+        if (idx == word.length()) return true;
+
+        //예외 처리 2
+        if (row < 0 || col < 0 || row >= board.length || col >= board[0].length) return false;
+
+        //예외 처리 3
+        if (visited[row][col]) return false;
+
+        //1. 글자 체크
+        if (board[row][col] != word.charAt(idx)) return false;
+
+        //방문 처리
+        visited[row][col] = true;
+
+        //상, 하, 좌, 우 찾기
+        boolean found = dfs(board, word, row + 1, col, idx + 1, visited)
+                || dfs(board, word, row - 1, col, idx + 1, visited)
+                || dfs(board, word, row, col + 1, idx + 1, visited)
+                || dfs(board, word, row, col - 1, idx + 1, visited);
+
+        visited[row][col] = false;
+        return found;
+    }
+}