Merge pull request #2488 from hyeri0903/main

[hyeri0903] WEEK 04 Solutions

Author: DaleSeo

coin-change/hyeri0903.java

@@ -0,0 +1,60 @@
+class Solution {
+    int minLen = Integer.MAX_VALUE;
+    public int coinChange(int[] coins, int amount) {
+        /**
+        1.문제: amount 를 만족시킬 수 있는 가장 적은 수의 coins
+        2.조건
+        - 모두 다른 값 integer로 구성된 배열
+        - amount 를 만들 수 없는 경우 -1 return
+        - coins.length 최소 1, 최대 12
+        - 원소값 최소 = 1
+        - amount 최소 = 0
+        3.풀이
+        - amount 를 만족시키는 최소 조합 길이를 구한다. dfs? -> TLE
+        - dp
+         */
+
+        int n = coins.length;
+        //최대 코인개수 = 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 >= 0) {
+                    dp[i] = Math.min(dp[i], dp[i-coin] + 1);
+                }
+            }
+        }
+        //amount 못만든 경우
+        if(dp[amount] > amount) {
+            return -1;
+        }
+        return dp[amount];
+
+        // if(n != 0 && amount == 0) return 0;
+        // Arrays.sort(coins);
+        // dfs(n - 1, 0, coins, amount, 0);
+        // if(minLen == Integer.MAX_VALUE) {
+        //     return -1;
+        // }
+        //return minLen;
+    }
+
+    void dfs(int index, int total, int[] coins, int amount, int count) {
+        if(total > amount) return;
+
+        if(total == amount) {
+            minLen = Math.min(minLen, count);
+            return;
+        }
+
+        if(count >= minLen) return;
+
+        for(int i = index; i >=0; i--) {
+            dfs(i, total + coins[i], coins, amount, count+1);
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+class Solution {
+    public int findMin(int[] nums) {
+        /**
+        1.problem: 오름차순 정렬된 original으로부터 최소횟수만큼 n번 rotate한다. 이 배열에서 최솟값 구하기
+        2.조건
+        - 주어진 배열은 1 ~ n 번 rotated 되었다.
+        - 배열의 원소는 모두 unique 한 값
+        - n = numslength
+        - O(log n)으로 풀이할것
+        - n = 1 ~ 5000
+        3.풀이
+        - bruteforce: nums 돌다가 작아지는 부분이 생기면 거기가 rotate 한 횟수, time : O(n), space: O(1)
+        - binary search: left, right 탐색
+
+        [1, 2, 3, 4, 5]
+        [5, 1, 2, 3, 4] -> 1
+        [4, 5, 1, 2, 3] -> 2
+        [3, 4, 5, 1, 2] -> 3 : index 3 구간에서 숫자 작아짐
+         */
+        int answer = nums[0];
+         int n = nums.length;
+         if(n == 1) return answer;
+
+        //sol 1)
+        // for(int i = 0; i < n-1; i++) {
+        //     if(nums[i] > nums[i+1]) {
+        //         return nums[i+1];
+        //     }
+        // }
+        //return answer;
+
+        //sol 2)
+        int left = 0;
+        int right = n - 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/hyeri0903.java

@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int maxDepth(TreeNode root) {
+        /**
+        문제: 바이너리트리의 maximum depth 구하기
+        조건
+        - 노드의 개수는 0 ~ 10^4
+        - node val 은 -100 ~ 100
+        풀이: dfs 로 depth 구하기
+        - 주어진 트리는 binary tree
+        - time complexity : O(n) , O(log n)
+        - space complexity : O(h)
+         */
+
+
+         if(root == null) return 0;
+
+         int height = dfs(root);
+        return height;
+    }
+
+    int dfs(TreeNode node) {
+        if(node == null) return 0;
+
+        int left = dfs(node.left);
+        int right = dfs(node.right);
+
+        return Math.max(left, right) + 1;
+    }
+}

merge-two-sorted-lists/hyeri0903.java

@@ -0,0 +1,40 @@
+/**
+ * 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) {
+        /**
+        time: O(n + m)
+        space: O(1)
+         */
+        if(list1 == null) return list2;
+        if(list2 == null) return list1;
+
+        ListNode res = new ListNode();
+        ListNode tmp = res;
+
+        while(list1 != null && list2 != null) {
+            if(list1.val > list2.val) {
+                tmp.next = list2;
+                list2 = list2.next;
+            } else {
+                tmp.next = list1;
+                list1 = list1.next;
+            }
+            tmp = tmp.next;
+        }
+        if(list1 == null) {
+            tmp.next = list2;
+        } else {
+            tmp.next = list1;
+        }
+        return res.next;
+    }
+}

word-search/hyeri0903.java

@@ -0,0 +1,40 @@
+class Solution {
+    public boolean exist(char[][] board, String word) {
+        /**
+        - backtracking (DFS)
+        - board[i][j] == word[0] 부터 start
+        - 상하좌우 탐색, 같은 칸 중복 탐색 x
+        - 틀리면 backtracking
+
+         */
+
+        for(int i = 0; i< board.length; i++) {
+            for(int j = 0; j< board[i].length; j++) {
+                if(dfs(i, j, 0, board, word)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    boolean dfs(int i, int j, int index, char[][] board, String word) {
+        //모두 다 찾은 경우
+        if(index == word.length()) return true;
+
+        //out of bound check
+        if(i < 0 || j < 0 || i >= board.length || j>= board[i].length || board[i][j] != word.charAt(index)) return false;
+
+        //방문처리
+        char cur = board[i][j];
+        board[i][j] = '#';
+
+        //4방향 탐색
+        boolean found = dfs(i+1, j, index+1, board, word) || dfs(i-1, j, index+1, board, word) || dfs(i, j+1, index+1, board, word) || dfs(i, j-1, index+1, board, word);
+
+        //backtracking
+        board[i][j] = cur;
+
+        return found;
+    }
+}