Week 12 solution

Author: sungjinwi

non-overlapping-intervals/sungjinwi.cpp

@@ -0,0 +1,19 @@
+class Solution {
+    public:
+        int eraseOverlapIntervals(vector<vector<int>>& intervals) {
+
+            sort(intervals.begin(), intervals.end(), [] (vector<int>& a, vector<int>& b){ return a[1] < b[1]; });
+    
+            int cnt = 0;
+            int lastEnd = INT_MIN;
+
+            for (auto& interval : intervals) {
+                if (interval[0] < lastEnd)
+                    cnt++;
+                else
+                    lastEnd = interval[1];
+            }
+
+            return cnt;
+        }
+    };

number-of-connected-components-in-an-undirected-graph/sungjinwi.cpp

@@ -0,0 +1,37 @@
+#include <vector>
+using namespace std;
+
+class Solution {
+    public:
+        /**
+         * @param n: the number of vertices
+         * @param edges: the edges of undirected graph
+         * @return: the number of connected components
+         */
+        int countComponents(int n, vector<vector<int>> &edges) {
+            vector<vector<int>> adjs(n);
+            vector<bool>    visited(n, false);
+            int result = 0;
+    
+            for (auto& edge : edges) {
+                adjs[edge[0]].push_back(edge[1]);
+                adjs[edge[1]].push_back(edge[0]);
+            }
+    
+            for (int i = 0; i < n; i++) {
+                if (!visited[i]) {
+                    dfs(i, adjs, visited);
+                    result++;
+                }
+            }
+            return result;
+        }
+    
+        void    dfs(int curr, vector<vector<int>>& adjs, vector<bool>& visited) {
+            if (visited[curr])
+                return ;
+            visited[curr] = true;
+            for (auto& adj : adjs[curr])
+                dfs(adj, adjs, visited);
+        }
+    };

remove-nth-node-from-end-of-list/sungjinwi.cpp

@@ -0,0 +1,29 @@
+/**
+ * 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* removeNthFromEnd(ListNode* head, int n) {
+            ListNode*   tmp = head;
+            vector<ListNode*>   list;
+    
+            while (tmp) {
+                list.push_back(tmp);
+                tmp = tmp->next;
+            }
+            int idx = list.size() - n;
+            if (idx == 0)
+                return head->next;
+            else {
+                list[idx - 1]->next = list[idx]->next;
+                return head;
+            }
+        }
+    };

same-tree/sungjinwi.cpp

@@ -0,0 +1,25 @@
+/**
+ * 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:
+        bool isSameTree(TreeNode* p, TreeNode* q) {
+            if (!p || !q)
+                return p == q;
+            if (p->val != q->val)
+                return false;
+            if (!isSameTree(p->left, q->left))
+                return false;
+            if (!isSameTree(p->right, q->right))
+                return false;
+            return true;
+        }
+    };

serialize-and-deserialize-binary-tree/sungjinwi.cpp

@@ -0,0 +1,83 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Codec {
+    public:
+    
+        // Encodes a tree to a single string.
+        string serialize(TreeNode* root) {
+            queue<TreeNode*>    q;
+            ostringstream out;
+    
+            out << "[";
+            if (root)
+                q.push(root);
+            while (!q.empty()) {
+                TreeNode*   node = q.front();
+                if (node == nullptr) {
+                    out << "null";
+                }
+                else {
+                    out << node->val;
+                    q.push(node->left);
+                    q.push(node->right);
+                }
+                q.pop();
+                out << ",";
+            }
+    
+            string result = out.str();
+            if (result.back() == ',')
+                result.pop_back();
+            result += "]";
+    
+            return result;
+        }
+    
+        // Decodes your encoded data to tree.
+        TreeNode* deserialize(string data) {
+            if (data == "[]")
+                return nullptr;
+            string  s = data.substr(1, data.size() - 2);
+            vector<string> tokens;
+            string  token;
+            stringstream ss(s);
+    
+            while (getline(ss, token, ','))
+                tokens.push_back(token);
+            
+            TreeNode*   root = new TreeNode(stoi(tokens[0]));
+            queue<TreeNode*>    q;
+            q.push(root);
+    
+            int index = 1;
+    
+            while (!q.empty() && index < tokens.size()) {
+                TreeNode* node = q.front();
+                q.pop();
+    
+                if (tokens[index] != "null") {
+                    node->left = new TreeNode(stoi(tokens[index]));
+                    q.push(node->left);
+                }
+                index++;
+    
+                if (index < tokens.size() && tokens[index] != "null") {
+                    node->right = new TreeNode(stoi(tokens[index]));
+                    q.push(node->right);
+                }
+                index++;
+            }
+            return root;
+        }
+    };
+    
+    // Your Codec object will be instantiated and called as such:
+    // Codec ser, deser;
+    // TreeNode* ans = deser.deserialize(ser.serialize(root));