Merge pull request #2476 from hwi-middle/main

[hwi-middle] WEEK 04 solutions

Author: hwi-middle

coin-change/hwi-middle.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    int coinChange(vector<int>& coins, int amount) {
+        if (amount < 1)
+        {
+            return 0;
+        }
+
+        vector<int> v(amount);
+        return solve(coins, amount, v);
+    }
+
+    int solve(vector<int>& coins, int amount, vector<int>& count)
+    {
+        if (amount < 0) return -1;
+        if (amount == 0) return 0;
+        if (count[amount - 1] != 0) return count[amount - 1];
+
+        int min = INT_MAX;
+        for (int coin : coins) 
+        {
+            int res = solve(coins, amount - coin, count); // coin을 사용
+            if (res >= 0 && res < min) // 결과가 유효하고 현재 최솟값보다 작으면 업데이트
+            {
+                min = res + 1; // coin을 미리 사용하고 찾은 값이므로 1 더함
+            }
+        }
+
+        count[amount - 1] = (min == INT_MAX) ? -1 : min;
+        return count[amount - 1];
+  }
+};

find-minimum-in-rotated-sorted-array/hwi-middle.cpp

@@ -0,0 +1,42 @@
+class Solution {
+public:
+    int findMin(vector<int>& nums) {
+        return solve(nums, 0, nums.size() - 1);
+    }
+
+    int solve(vector<int>& num, int start, int end)
+    {
+        if (end - start < 2)
+        {
+            return min(num[start], num[end]);
+        }
+
+        // 중간 인덱스 계산
+        int mid = (start + end) / 2;
+
+        // 오름차순 정렬이 깨지기 시작한 부분 -> 최솟값 발견
+        if  (num[mid] < num[mid - 1])
+        {
+            return num[mid];
+        }
+
+        // 왼쪽 영역이 정렬되어 있는 경우
+        if (num[start] <= num[mid])
+        {
+            // 그리고 오른쪽 영역까지도 정렬된 경우
+            if (num[mid] <= num[end])
+            {
+                // 가장 왼쪽에 있는 값이 최솟값
+                return num[start];
+            }
+
+            // 왼쪽 영역만 정렬된 경우
+            // 오른쪽 영역에서 정렬이 깨지는 부분 찾으러 가기
+            return solve(num, mid + 1, end);
+        }
+
+        // 오른쪽 영역이 정렬된 경우
+        // 왼쪽 영역에서 정렬이 깨지는 부분 찾으러 가기
+        return solve(num, start, mid - 1);
+    }
+};

maximum-depth-of-binary-tree/hwi-middle.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+        return solve(root, 0);
+    }
+
+    int solve(TreeNode* root, int depth)
+    {
+        if (root == nullptr)
+        {
+            return depth;
+        }
+
+        int l = solve(root->left, depth);
+        int r = solve(root->right, depth);
+
+        return max(l, r) + 1;
+    }
+};

merge-two-sorted-lists/hwi-middle.cpp

@@ -0,0 +1,38 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
+        ListNode dummy; // head 초기화의 복잡성을 낮추기 위한 더미노드
+        ListNode* tail = &dummy;
+
+        while (list1 != nullptr && list2 != nullptr)
+        {
+            if (list1->val < list2->val)
+            {
+                tail->next = list1;
+                list1 = list1->next;
+            }
+            else
+            {
+                tail->next = list2;
+                list2 = list2->next;
+            }
+
+            tail = tail->next;
+        }
+
+        tail->next = (list1 == nullptr) ? list2 : list1;
+
+        return dummy.next;
+    }
+}
+;

word-search/hwi-middle.cpp

@@ -0,0 +1,65 @@
+class Solution {
+private:
+    int row;
+    int col;
+
+public:
+    bool exist(vector<vector<char>>& board, string word) {
+        row = board.size();
+        col = board[0].size();
+        for (int r = 0; r < row; ++r)
+        {
+            for (int c = 0; c < col; ++c)
+            {
+                if (solve(board, word, r, c, 0))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    // dfs 함수
+    bool solve(vector<vector<char>>& board, string& word, int r, int c, int idx)
+    {
+        // 범위를 벗어난 경우
+        if (r < 0 || r >= row || c < 0 || c >= col) 
+        {
+            return false;
+        }
+
+        // 글자가 맞지 않는 경우
+        if (board[r][c] != word[idx])
+        {
+            return false;
+        }
+
+        // 단어를 찾은 경우
+        if (idx == word.size() - 1)
+        {
+            return true;
+        }
+        
+        char ch = board[r][c];
+        board[r][c] = '?'; // 이미 방문한 곳으로 돌아오지 않도록 입력으로 들어오지 않는 문자로 치환
+
+        // 상하좌우 탐색
+        int dr[4] = { 1, 0, -1, 0 };
+        int dc[4] = { 0, 1, 0, -1 };
+
+        for (int dir = 0; dir < 4; ++dir)
+        {
+            int nr = r + dr[dir];
+            int nc = c + dc[dir];
+            if (solve(board, word, nr, nc, idx + 1))
+            {
+                return true;
+            }
+        }
+        
+        board[r][c] = ch; // 원래 문자로 되돌리기
+        return false;
+    }
+};