[ys-han00] WEEK 10 solutions

course-schedule/ys-han00.cpp

@@ -0,0 +1,38 @@
+class Solution {
+public:
+    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
+        int visited = 0;
+        vector<vector<int>> outdegree(numCourses, vector<int>());
+        vector<int> indegree(numCourses, 0);
+
+        for(auto edge : prerequisites) {
+            outdegree[edge[0]].push_back(edge[1]);
+            indegree[edge[1]]++;
+        }
+
+        queue<int> que;
+        for(int i = 0; i < numCourses; i++) {
+            if(indegree[i] == 0) {
+                que.push(i);
+                visited++;
+            }
+        }
+
+
+        while(!que.empty()) {
+            int now = que.front();
+            que.pop();
+
+            for(auto next : outdegree[now]) {
+                indegree[next]--;
+                if(indegree[next] == 0) {
+                    visited++;
+                    que.push(next);
+                }
+            }
+        }
+
+        return (visited == numCourses ? true : false);
+    }
+};
+

invert-binary-tree/ys-han00.cpp

@@ -0,0 +1,33 @@
+/**
+ * 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:
+    TreeNode* invertTree(TreeNode* root) {
+        queue<TreeNode*> que;
+        que.push(root);
+
+        while(!que.empty()) {
+            TreeNode *curr = que.front();
+            que.pop();
+
+            if(!curr)
+                continue;
+
+            swap(curr->left, curr->right);
+            que.push(curr->left);
+            que.push(curr->right);
+        }
+
+        return root;
+    }
+};
+

jump-game/ys-han00.cpp

@@ -0,0 +1,34 @@
+// class Solution {
+// public:
+//     bool canJump(vector<int>& nums) {
+//         int n = nums.size();
+//         vector<bool> dp(n);
+
+//         dp[n - 1] = true;
+//         for(int i = n - 2; i >= 0; i--) {
+//             for(int j = min(n - 1, nums[i] + i); i <= j; j--) {
+//                 if(dp[j]) {
+//                     dp[i] = true;
+//                     break;
+//                 }
+//             }
+//         }
+
+//         return dp[0];
+//     }
+// };
+
+class Solution {
+public:
+    bool canJump(vector<int>& nums) {
+        int maxPos = 0;
+        for(int i = 0; i < nums.size(); i++) {
+            if(maxPos < i)
+                return false;
+            maxPos = max(maxPos, i + nums[i]);
+        }
+
+        return true;
+    }
+};
+

merge-k-sorted-lists/ys-han00.cpp

@@ -0,0 +1,68 @@
+/**
+ * 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* mergeKLists(vector<ListNode*>& lists) {
+//         vector<int> nums;
+//         for(ListNode* list : lists) {
+//             while(list != nullptr) {
+//                 nums.push_back(list->val);
+//                 list = list->next;
+//             }
+//         }
+
+//         if(nums.size() == 0)
+//             return nullptr;
+
+//         sort(nums.begin(), nums.end());
+//         ListNode* root = new ListNode(nums[0]);
+//         ListNode* curr = root;
+
+//         for(int i = 1; i < nums.size(); i++) {
+//             curr->next = new ListNode(nums[i]);
+//             curr = curr->next;
+//         }
+
+//         return root;
+//     }
+// };
+
+class Solution {
+public:
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        priority_queue<
+            pair<int, int>,
+            vector<pair<int, int>>,
+            greater<pair<int, int>>
+        > pq;
+
+        for(int i = 0; i < lists.size(); i++)
+            if(lists[i]) 
+                pq.push({lists[i]->val, i});
+
+        ListNode dummy(-1);
+        ListNode* curr = &dummy;
+        while(!pq.empty()) {
+            auto [val, idx] = pq.top();
+            pq.pop();
+
+            curr->next = new ListNode(val);
+            curr = curr->next;
+
+            lists[idx] = lists[idx]->next;
+            if(lists[idx])
+                pq.push({lists[idx]->val, idx});
+        }
+
+        return dummy.next;
+    }
+};
+

search-in-rotated-sorted-array/ys-han00.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int search(vector<int>& nums, int target) {
+        int left = 0, right = nums.size() - 1, mid;
+
+        while(left <= right) {
+            mid = (left + right) / 2;
+
+            if(target == nums[mid])
+                return mid;
+
+            if(nums[left] <= nums[mid]) {
+                if(nums[left] <= target && target < nums[mid])
+                    right = mid - 1;
+                else
+                    left = mid + 1;
+            }
+            else {
+                if(nums[mid] < target && target <= nums[right])
+                    left = mid + 1;
+                else
+                    right = mid - 1;
+            }
+        }
+
+        return -1;
+    }
+};
+