[hwi-middle] WEEK 10 solutions

course-schedule/hwi-middle.cpp

@@ -0,0 +1,64 @@
+class Solution {
+private:
+    enum class eVisitStatus 
+    {
+        Unvisited, 
+        Visiting,
+        Visited 
+    };
+
+public:
+    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
+        vector<vector<int>> graph(numCourses);
+
+        for (auto& p : prerequisites) 
+        {
+            int course = p[0];
+            int prerequisite = p[1];
+
+            graph[course].push_back(prerequisite);
+        }
+
+        vector<eVisitStatus> status(numCourses, eVisitStatus::Unvisited);
+
+        for (int i = 0; i < numCourses; ++i) 
+        {
+            if (status[i] == eVisitStatus::Unvisited) 
+            {
+                if (!dfs(i, graph, status)) 
+                {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+private:
+    bool dfs(int course, vector<vector<int>>& graph, vector<eVisitStatus>& status) 
+    {
+        if (status[course] == eVisitStatus::Visiting) 
+        {
+            return false;
+        }
+
+        if (status[course] == eVisitStatus::Visited) 
+        {
+            return true;
+        }
+
+        status[course] = eVisitStatus::Visiting;
+
+        for (int prerequisite : graph[course]) 
+        {
+            if (!dfs(prerequisite, graph, status)) 
+            {
+                return false;
+            }
+        }
+
+        status[course] = eVisitStatus::Visited;
+        return true;
+    }
+};

invert-binary-tree/hwi-middle.cpp

@@ -0,0 +1,26 @@
+/**
+ * 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) {
+        if (root == nullptr || (root->left == nullptr && root->right == nullptr))
+        {
+            return root;
+        }
+
+        invertTree(root->left);
+        invertTree(root->right);
+        swap(root->left, root->right);
+
+        return root;
+    }
+};

jump-game/hwi-middle.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    bool canJump(vector<int>& nums) {
+        int maxDist = 0;
+
+        for (int i = 0; i < nums.size(); ++i)
+        {
+            if (maxDist < i)
+            {
+                return false;
+            }
+
+            maxDist = max(maxDist, i + nums[i]);
+        }
+
+        return true;
+    }
+};

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

@@ -0,0 +1,58 @@
+/**
+ * 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 {
+private:
+    struct cmp
+    {
+        bool operator() (ListNode* a, ListNode* b)
+        {
+            return a->val > b->val;
+        }
+    };
+
+public:
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        if (lists.empty())
+        {
+            return nullptr;
+        }
+
+        priority_queue<ListNode*, vector<ListNode*>, cmp> pq;
+
+        for (ListNode* list: lists)
+        {
+            while (list != nullptr)
+            {
+                pq.push(list);
+                list = list->next;
+            }
+        }
+
+        if (pq.empty())
+        {
+            return nullptr;
+        }
+
+        ListNode* res = pq.top();
+        ListNode* prev = res;
+        while (!pq.empty())
+        {
+            ListNode* n = pq.top();
+            pq.pop();
+            prev->next = n;
+            prev = n;
+        }
+
+        prev->next = nullptr;
+
+        return res;
+    }
+};

search-in-rotated-sorted-array/hwi-middle.cpp

@@ -0,0 +1,38 @@
+class Solution {
+public:
+    int search(vector<int>& nums, int target) {
+        return searchImpl(nums, 0, nums.size() - 1, target);
+    }
+
+private:
+    int searchImpl(vector<int>& nums, int start, int end, int target)
+    {
+        if (start > end)
+        {
+            return -1;
+        }
+
+        int mid = (start + end) / 2;
+        if (nums[mid] == target)
+        {
+            return mid;
+        }
+
+        if (nums[start] <= nums[mid]) 
+        {
+            if (nums[start] <= target && nums[mid] >= target) 
+            {
+                return searchImpl(nums, start, mid - 1, target);
+            }
+
+            return searchImpl(nums, mid + 1, end, target);
+        }
+
+        if (nums[mid] <= target && nums[end] >= target)
+        {
+            return searchImpl(nums, mid + 1, end, target);
+        }
+
+        return searchImpl(nums, start, mid - 1, target);
+    }
+};