[hwi-middle] WEEK 11 solutions

binary-tree-maximum-path-sum/hwi-middle.cpp

@@ -0,0 +1,40 @@
+/**
+ * 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 maxPathSum(TreeNode* root) {
+        int ans = -1000;
+        impl(root, ans);
+        return ans;
+    }
+
+private:
+    int impl(TreeNode* root, int& ans)
+    {
+        if (root == nullptr)
+        {
+            return 0;
+        }
+
+        // 왼쪽과 오른쪽 자식을 재귀적으로 순회
+        int l = impl(root->left, ans);
+        int r = impl(root->right, ans);
+        int cur = root->val;
+
+        // 최댓값 업데이트
+        ans = max(ans, max(0, l) + max(0, r) + cur);
+
+        // 부모에게 전달할 값
+        // -> 재방문이 허용되지 않으므로 최댓값과는 다름
+        return max(0, max(l, r) + cur);
+    }
+};

graph-valid-tree/hwi-middle.cpp

@@ -0,0 +1,47 @@
+class Solution {
+public:
+    bool validTree(int n, vector<vector<int>>& edges) {
+        vector<vector<int>> adj(n + 1);
+        vector<bool> vis(n + 1);
+
+        for (vector<int>& edge : edges)
+        {
+            adj[edge[0]].push_back(edge[1]);
+            adj[edge[1]].push_back(edge[0]);
+        }
+
+        // BFS 수행
+        int visited = 1;
+        queue<pair<int, int>> q;
+        q.push({0, -1});
+        while (!q.empty())
+        {
+            int cur;
+            int parent;
+            tie(cur, parent) = q.front();
+            q.pop();
+
+            for (int n : adj[cur])
+            {
+                // 자기가 왔던 노드면 넘어감
+                if (n == parent)
+                {
+                    continue;
+                }
+
+                // 이미 방문한 노드면 유효하지 않음
+                if (vis[n])
+                {
+                    return false;
+                }
+
+                vis[n] = true;
+                visited++;
+                q.push({n, cur});
+            }
+        }
+
+        // BFS를 통해 전체 노드를 방문할 수 있었어야 함
+        return visited == n;
+    }
+};

merge-intervals/hwi-middle.cpp

@@ -0,0 +1,39 @@
+class Solution {
+public:
+    vector<vector<int>> merge(vector<vector<int>>& intervals) {
+        // start 순으로 정렬
+        sort(intervals.begin(), intervals.end(),
+             [](const vector<int>& a, const vector<int>& b) {
+                 return a[0] < b[0];
+             });
+
+        vector<vector<int>> res;
+        res.reserve(intervals.size());
+
+        int start = intervals[0][0];
+        int end = intervals[0][1];
+
+        for (int i = 1; i < intervals.size(); ++i) 
+        {
+            // 현재 구간의 end보다 start가 크다면 틈이 벌어진 것
+            if (end < intervals[i][0])
+            {
+                vector<int> v = { start, end };
+                res.push_back(v);
+                start = intervals[i][0];
+                end = intervals[i][1];
+            }
+            // 그렇지 아니면 합칠 수 있음
+            else
+            {
+                start = min(start, intervals[i][0]);
+                end = max(end, intervals[i][1]);
+            }
+        }
+
+        vector<int> v = { start, end };
+        res.push_back(v);
+
+        return res;
+    }
+};

missing-number/hwi-middle.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int missingNumber(vector<int>& nums) {
+        // 1부터 n까지 합을 구하고, 배열 요소들의 합을 빼서 빠진 수를 찾음
+        int n = nums.size();
+        int sum = (n * (n + 1)) / 2;
+        int acc = 0;
+        for (int num : nums)
+        {
+            acc += num;
+        }
+
+        return sum - acc;
+    }
+};

reorder-list/hwi-middle.cpp

@@ -0,0 +1,53 @@
+/**
+ * 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) {}
+ * };
+ */
+
+ // Editorial 코드
+class Solution {
+public:
+    void reorderList(ListNode* head)  {
+        if (head == nullptr) 
+        {
+            return;
+        }
+
+        ListNode* slow = head;
+        ListNode* fast = head;
+        while (fast != nullptr && fast->next != nullptr) 
+        {
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+
+        ListNode* prev = nullptr;
+        ListNode* curr = slow;
+        ListNode* tmp;
+        while (curr != nullptr) 
+        {
+            tmp = curr->next;
+            curr->next = prev;
+            prev = curr;
+            curr = tmp;
+        }
+
+
+        ListNode* first = head;
+        ListNode* second = prev;
+        while (second->next != nullptr) 
+        {
+            tmp = first->next;
+            first->next = second;
+            first = tmp;
+            tmp = second->next;
+            second->next = first;
+            second = tmp;
+        }
+    }
+};