#241 & #251 solutions

Author: ys-han00

3sum/ys-han00.cpp

@@ -0,0 +1,75 @@
+// class Solution {
+// public:
+//     vector<vector<int>> threeSum(vector<int>& nums) {
+//         set<vector<int>> ans;
+//         map<int, int> counter; // {num : cnt}
+//         vector<int> targets;
+//         int target, left, right;
+        
+//         for(int i = 0; i < nums.size(); i++)
+//             counter[nums[i]]++;
+        
+//         for(auto iter : counter)
+//             targets.push_back(iter.first);
+
+//         for(int i = 0; i < targets.size(); i++) {
+//             target = -1 * targets[i];
+            
+//             vector<int> new_nums;
+//             counter[targets[i]]--;
+//             for(auto iter : counter) {
+//                 for(int j = 0; j < iter.second; j++)
+//                     new_nums.push_back(iter.first);
+//             }
+//             left = 0; right = new_nums.size() - 1;
+//             while(left < right) {
+//                 int sum = new_nums[left] + new_nums[right];
+//                 if(sum == target && targets[i] <= new_nums[left] && new_nums[left] <= new_nums[right])
+//                     ans.insert(vector<int>({targets[i], new_nums[left], new_nums[right]}));
+            
+//                 if(sum < target)
+//                     left++;
+//                 else
+//                     right--;
+//             }
+//             counter[targets[i]]++;
+//         }
+        
+//         return vector<vector<int>> (ans.begin(), ans.end());
+//     }
+// };
+
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        vector<vector<int>> ans;
+        int left, right, sum;
+
+        sort(nums.begin(), nums.end());
+
+        for(int i = 0; i < nums.size(); i++) {
+            if(i > 0 && nums[i] == nums[i - 1])
+                continue;
+
+            left = i + 1; right = nums.size() - 1;
+            while(left < right) {
+                sum = nums[i] + nums[left] + nums[right];
+                if(sum == 0) {
+                    ans.push_back(vector<int> ({nums[i], nums[left], nums[right]}));
+                    left++; right--;
+                    while(left < right && nums[left] == nums[left - 1])
+                        left++;
+                    while(left < right && nums[right] == nums[right + 1])
+                        right--;
+                }
+                else if(sum < 0)
+                    left++;
+                else if(sum > 0)
+                    right--;
+            }
+        }
+
+        return ans;
+    }
+};
+

validate-binary-search-tree/ys-han00.cpp

@@ -0,0 +1,79 @@
+/**
+ * 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 isValidBST(TreeNode* root) {
+//         queue<pair<TreeNode*, vector<pair<int, int>>>> que;
+//         int val, dir, num;
+        
+//         que.push({root, vector<pair<int, int>> ()});
+//         while(!que.empty()) {
+//             TreeNode* node = que.front().first;
+//             vector<pair<int, int>> path = que.front().second;
+//             que.pop();
+            
+//             val = node->val;
+        
+//             for(int i = 0; i < path.size(); i++) {
+//                 num = path[i].first;
+//                 dir = path[i].second;
+//                 if(dir == 0 && num <= val)
+//                     return false;
+//                 if(dir == 1 && val <= num)
+//                     return false;
+//             }
+            
+//             if(!node->left && !node->right) 
+//                 continue;
+
+//             if(node->left) {
+//                 path.push_back({val, 0});
+//                 que.push({node->left, path});
+//                 path.pop_back();
+//             }
+
+//             if(node->right) {
+//                 path.push_back({val, 1});
+//                 que.push({node->right, path});
+//                 path.pop_back();
+//             }
+//         }
+        
+//         return true;
+//     }
+// };
+
+class Solution {
+public:
+    void inorder(TreeNode* root, vector<int>& ordered) {
+        if(root==NULL)
+            return;
+
+        inorder(root->left, ordered);
+        ordered.push_back(root->val);
+        inorder(root->right, ordered);
+    }
+
+    bool isValidBST(TreeNode* root) {
+        vector<int> ordered;
+        
+        inorder(root, ordered);
+        
+        for(int i = 1; i < ordered.size(); i++)
+            if(ordered[i - 1] >= ordered[i])
+                return false;
+        
+        return true;
+    }
+};
+