[ys-han00] WEEK 02 solutions

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;
+    }
+};
+

climbing-stairs/ys-han00.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int climbStairs(int n) {
+        vector<int> fibo(46, 0);
+
+        fibo[1] = 1;
+        fibo[2] = 2;
+
+        if(n <= 2)
+            return fibo[n];
+
+        for(int i = 3; i <= n; i++)
+            fibo[i] = fibo[i - 1] + fibo[i - 2];
+
+        return fibo[n];
+    }
+};
+

product-of-array-except-self/ys-han00.cpp

@@ -0,0 +1,72 @@
+// class Solution {
+// public:
+//     vector<int> productExceptSelf(vector<int>& nums) {
+//         int mul = 1, zero_cnt = 0;
+
+//         for(int i = 0; i < nums.size(); i++) {
+//             if(nums[i] != 0)
+//                 mul *= nums[i];
+//             else
+//                 zero_cnt++;
+//         }
+
+//         vector<int> ans = vector<int>(nums.size(), 0);
+
+//         if(zero_cnt == 1) {
+//             for(int i = 0; i < nums.size(); i++) {
+//                 if(nums[i] == 0) {
+//                     ans[i] = mul;
+//                     break;
+//                 }
+//             }
+//         } else if(zero_cnt == 0) {
+//             for(int i = 0; i < nums.size(); i++)
+//                 ans[i] = mul / nums[i];
+//         }
+
+//         return ans;
+//     }
+// };
+
+// class Solution {
+// public:
+//     vector<int> productExceptSelf(vector<int>& nums) {
+//         int mul = 1, zero_cnt = 0;
+//         vector<int> prefix(nums.size(), 0), postfix(nums.size(), 0);
+
+//         prefix[0] = 1;
+//         for(int i = 1; i < nums.size(); i++)
+//             prefix[i] = nums[i - 1] * prefix[i - 1];
+
+//         postfix[nums.size() - 1] = 1;
+//         for(int i = nums.size() - 2; i >= 0; i--)
+//             postfix[i] = nums[i + 1] * postfix[i + 1];
+
+//         vector<int> ans = vector<int>(nums.size(), 0);
+//         for(int i = 0; i < nums.size(); i++)
+//             ans[i] = postfix[i] * prefix[i];
+
+//         return ans;
+//     }
+// };
+
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        vector<int> ans(nums.size(), 1);
+        int before = 1, after = 1;
+
+        for(int i = 0; i < nums.size() - 1; i++) {
+            before *= nums[i];
+            ans[i + 1] *= before;
+        }
+
+        for(int i = nums.size() - 1; i > 0; i--) {
+            after *= nums[i];
+            ans[i - 1] *= after;
+        }
+
+        return ans;
+    }
+};
+

valid-anagram/ys-han00.cpp

@@ -0,0 +1,36 @@
+// class Solution {
+// public:
+//     bool isAnagram(string s, string t) {
+//         map<char, int> counter;
+
+//         for(int i = 0; i < s.size(); i++)
+//             counter[s[i] - 'a']++;
+//         for(int i = 0; i < t.size(); i++)
+//             counter[t[i] - 'a']--;
+
+//         for(auto const& iter : counter)
+//             if(iter.second != 0)
+//                 return false;
+
+//         return true;
+//     }
+// };
+
+class Solution {
+public:
+    bool isAnagram(string s, string t) {
+        vector<int> counter(26, 0);
+
+        for(int i = 0; i < s.size(); i++)
+            counter[s[i] - 'a']++;
+        for(int i = 0; i < t.size(); i++)
+            counter[t[i] - 'a']--;
+
+        for(int i = 0; i < 26; i++)
+            if(counter[i] != 0)
+                return false;
+
+        return true;
+    }
+};
+

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;
+    }
+};
+