[ys-han00] WEEK 11 solutions Solutions

binary-tree-maximum-path-sum/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:
+    int max_sum = INT_MIN;
+
+    int dfs(TreeNode* node) {
+        if(!node)
+            return 0;
+
+        int left_max = max(dfs(node->left), 0);
+        int right_max = max(dfs(node->right), 0);
+
+        max_sum = max(node->val + left_max + right_max, max_sum);
+
+        return node->val + max(left_max, right_max);
+    }
+
+    int maxPathSum(TreeNode* root) {
+        dfs(root);
+        return max_sum;
+    }
+};
+

merge-intervals/ys-han00.cpp

@@ -0,0 +1,40 @@
+class Solution {
+public:
+    vector<vector<int>> merge(vector<vector<int>>& intervals) {
+        sort(intervals.begin(), intervals.end());
+
+        vector<vector<int>> ans;        
+        for (const auto& interval : intervals) {
+            if (ans.empty() || ans.back()[1] < interval[0])
+                ans.push_back(interval);
+            else
+                ans.back()[1] = max(ans.back()[1], interval[1]);
+        }
+
+        return ans;
+    }
+
+    // vector<vector<int>> merge(vector<vector<int>>& intervals) {
+    //     vector<vector<int>> ans;
+    //     sort(intervals.begin(), intervals.end());
+
+    //     int idx = 0, s, e;
+    //     s = intervals[idx][0];
+    //     e = intervals[idx][1];
+    //     idx++;
+    //     while(idx < intervals.size()) {
+    //         if(e < intervals[idx][0]) {
+    //             ans.push_back(vector<int>({s, e}));
+    //             s = intervals[idx][0];
+    //             e = intervals[idx][1];
+    //         } else {
+    //             e = max(e, intervals[idx][1]);
+    //         }
+    //         idx++;
+    //     }
+    //     ans.push_back(vector<int>({s, e}));
+
+    //     return ans;
+    // }
+};
+

missing-number/ys-han00.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+    // int missingNumber(vector<int>& nums) {
+    //     sort(nums.begin(), nums.end());
+
+    //     for(int i = 0; i < nums.size(); i++)
+    //         if(i != nums[i])
+    //             return i;
+
+    //     return nums.size();
+    // }
+
+    // int missingNumber(vector<int>& nums) {
+    //     int ans = nums.size();
+    //     for(int i = 0; i < nums.size(); i++)
+    //         ans ^= i ^ nums[i];
+    //     return ans;
+    // }
+
+    int missingNumber(vector<int>& nums) {
+        int idx = 0;
+        while(idx < nums.size()) {
+            int val = nums[idx];
+            if(val <  nums.size() && val != idx)
+                swap(nums[idx], nums[val]);
+            else
+                idx++;
+        }
+
+        for(int i = 0; i < nums.size(); i++)
+            if(i != nums[i])
+                return i;
+
+        return nums.size();
+    }
+};
+

reorder-list/ys-han00.cpp

@@ -0,0 +1,100 @@
+/**
+ * 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:
+    void reorderList(ListNode* head) {
+        ListNode* slow = head;
+        ListNode* fast = head;
+        while (fast->next && fast->next->next) {
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+
+        ListNode* curr = slow->next;
+        slow->next = nullptr; 
+        ListNode* prev = nullptr;
+
+        while (curr) {
+            ListNode* temp = curr->next;
+            curr->next = prev;
+            prev = curr;
+            curr = temp;
+        }
+
+        ListNode* first = head;
+        ListNode* second = prev;
+
+        while (second) {
+            ListNode* temp1 = first->next;
+            ListNode* temp2 = second->next;
+
+            first->next = second;
+            second->next = temp1;
+
+            first = temp1;
+            second = temp2;
+        }
+    }
+
+    // void reorderList(ListNode* head) {
+    //     ListNode* now = head;
+    //     stack<ListNode*> sta;
+
+    //     while(now) {
+    //         sta.push(now);
+    //         now = now->next;
+    //     }
+
+    //     now = head;
+    //     int n = sta.size();
+    //     for(int i = 0; i < n / 2; i++) {
+    //         ListNode* tail = sta.top();
+    //         sta.pop();
+
+    //         tail->next = now->next;
+    //         now->next = tail;
+    //         now = tail->next;
+    //     }
+
+    //     now->next = nullptr;
+    // }
+
+    // void reorderList(ListNode* head) {
+    //     ListNode* now = head;
+    //     stack<ListNode*> sta;
+
+    //     while(now) {
+    //         sta.push(now);
+    //         now = now->next;
+    //     }
+
+    //     now = head;
+    //     int cnt = 0;
+    //     int node_cnt = sta.size();
+    //     while(cnt < node_cnt / 2) {
+    //         if(cnt != node_cnt / 2 - 1)
+    //             sta.top()->next = now->next;
+    //         else {
+    //             if(node_cnt & 1) {
+    //                 now->next->next = nullptr;
+    //                 sta.top()->next = now->next;
+    //             }
+    //             else
+    //                 sta.top()->next = nullptr;
+    //         }
+    //         now->next = sta.top();
+    //         now = sta.top()->next;
+    //         sta.pop();
+    //         cnt++;
+    //     }
+    // }
+};
+