copy cpp files to fit directory structure

Author: Ahmad-A0

cpp/1-Two-Sum.cpp

@@ -0,0 +1,30 @@
+/*
+    Given int array & target, return indices of 2 nums that add to target
+    Ex. nums = [2,7,11,15] & target = 9 -> [0,1], 2 + 7 = 9
+
+    At each num, calculate complement, if exists in hash map then return
+
+    Time: O(n)
+    Space: O(n)
+*/
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> m;
+        vector<int> result;
+        
+        for (int i = 0; i < nums.size(); i++) {
+            int complement = target - nums[i];
+            if (m.find(complement) != m.end()) {
+                result.push_back(m[complement]);
+                result.push_back(i);
+                break;
+            } else {
+                m.insert({nums[i], i});
+            }
+        }
+        
+        return result;
+    }
+};

cpp/10-Regular-Expression-Matching.cpp

@@ -0,0 +1,49 @@
+/*
+    Given string & pattern, implement RegEx matching
+    '.' -> matches any single character
+    '*' -> matches zero or more of the preceding element
+    Matching should cover the entire input string (not partial)
+    Ex. s = "aa", p = "a" -> false, "a" doesn't match entire string "aa"
+
+    DFS + memo, 2 choices at a *: either use it, or don't use it
+
+    Time: O(m x n)
+    Space: O(m x n)
+*/
+
+class Solution {
+public:
+    bool isMatch(string s, string p) {
+        return dfs(s, p, 0, 0);
+    }
+private:
+    map<pair<int, int>, bool> dp;
+    
+    bool dfs(string& s, string& p, int i, int j) {
+        if (dp.find({i, j}) != dp.end()) {
+            return dp[{i, j}];
+        }
+        
+        if (i >= s.size() && j >= p.size()) {
+            return true;
+        }
+        if (j >= p.size()) {
+            return false;
+        }
+        
+        bool match = i < s.size() && (s[i] == p[j] || p[j] == '.');
+        if (j + 1 < p.size() && p[j + 1] == '*') {
+            // choices: either (1) don't use *, or (2) use *
+            dp[{i, j}] = dfs(s, p, i, j + 2) || (match && dfs(s, p, i + 1, j));
+            return dp[{i, j}];
+        }
+        
+        if (match) {
+            dp[{i, j}] = dfs(s, p, i + 1, j + 1);
+            return dp[{i, j}];
+        }
+        
+        dp[{i, j}] = false;
+        return dp[{i, j}];
+    }
+};

cpp/100-Same-Tree.cpp

@@ -0,0 +1,36 @@
+/*
+    Given roots of 2 binary trees, check if they're the same or not (same structure & values)
+    Ex. p = [1,2,3] q = [1,2,3] -> true, p = [1,2] q = [1,null,2] -> false
+
+    Check: (1) matching nulls, (2) non-matching nulls, (3) non-matching values
+
+    Time: O(n)
+    Space: O(n)
+*/
+
+/**
+ * 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 == NULL && q == NULL) {
+            return true;
+        }
+        if (p == NULL || q == NULL) {
+            return false;
+        }
+        if (p->val != q->val) {
+            return false;
+        }
+        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
+    }
+};

cpp/102-Binary-Tree-Level-Order-Traversal.cpp

@@ -0,0 +1,57 @@
+/*
+    Given root of binary tree, return level order traversal of its nodes (left to right)
+    Ex. root = [3,9,20,null,null,15,7] -> [[3],[9,20],[15,7]]
+
+    Standard BFS traversal, at each level, push left & right nodes if they exist to queue
+
+    Time: O(n)
+    Space: O(n)
+*/
+
+/**
+ * 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:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> result;
+        
+        if (root == NULL) {
+            return result;
+        }
+        
+        queue<TreeNode*> q;
+        q.push(root);
+        
+        while (!q.empty()) {
+            int count = q.size();
+            vector<int> curr;
+            
+            for (int i = 0; i < count; i++) {
+                TreeNode* node = q.front();
+                q.pop();
+                
+                curr.push_back(node->val);
+                
+                if (node->left != NULL) {
+                    q.push(node->left);
+                }
+                if (node->right != NULL) {
+                    q.push(node->right);
+                }
+            }
+            
+            result.push_back(curr);
+        }
+        
+        return result;
+    }
+};

cpp/104-Maximum-Depth-Of-Binary-Tree.cpp

@@ -0,0 +1,56 @@
+/*
+    Given root of binary tree, return max depth (# nodes along longest path from root to leaf)
+
+    At every node, max depth is the max depth between its left & right children + 1
+
+    Time: O(n)
+    Space: O(n)
+*/
+
+/**
+ * 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 maxDepth(TreeNode* root) {
+        if (root == NULL) {
+            return 0;
+        }
+        return 1 + max(maxDepth(root->left), maxDepth(root->right));
+    }
+};
+
+// class Solution {
+// public:
+//     int maxDepth(TreeNode* root) {
+//         if (root == NULL) {
+//             return 0;
+//         }
+//         queue<TreeNode*> q;
+//         q.push(root);
+//         int result = 0;
+//         while (!q.empty()) {
+//             int count = q.size();
+//             for (int i = 0; i < count; i++) {
+//                 TreeNode* node = q.front();
+//                 q.pop();
+//                 if (node->left != NULL) {
+//                     q.push(node->left);
+//                 }
+//                 if (node->right != NULL) {
+//                     q.push(node->right);
+//                 }
+//             }
+//             result++;
+//         }
+//         return result;
+//     }
+// };

cpp/1046-Last-Stone-Weight.cpp

@@ -0,0 +1,35 @@
+/*
+    Given array of stones to smash, return smallest possible weight of last stone
+    If x == y both stones destroyed, if x != y stone x destroyed, stone y = y - x
+    Ex. stones = [2,7,4,1,8,1] -> 1, [2,4,1,1,1], [2,1,1,1], [1,1,1], [1]
+
+    Max heap, pop 2 biggest, push back difference until no more 2 elements left
+
+    Time: O(n log n)
+    Space: O(n)
+*/
+
+class Solution {
+public:
+    int lastStoneWeight(vector<int>& stones) {
+        priority_queue<int> pq;
+        for (int i = 0; i < stones.size(); i++) {
+            pq.push(stones[i]);
+        }
+        
+        while (pq.size() > 1) {
+            int y = pq.top();
+            pq.pop();
+            int x = pq.top();
+            pq.pop();
+            if (y > x) {
+                pq.push(y - x);
+            }
+        }
+        
+        if (pq.empty()) {
+            return 0;
+        }
+        return pq.top();
+    }
+};

cpp/105-Construct-Binary-Tree-From-Preorder-And-Inorder.cpp

@@ -0,0 +1,50 @@
+/*
+    Given 2 integer arrays preorder & inorder, construct & return the binary tree
+    Ex. preorder = [3,9,20,15,7], inorder = [9,3,15,20,7] -> [3,9,20,null,null,15,7]
+
+    Preorder dictates nodes, inorder dictates subtrees (preorder values, inorder positions)
+
+    Time: O(n)
+    Space: O(n)
+*/
+
+/**
+ * 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:
+    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
+        int index = 0;
+        return build(preorder, inorder, index, 0, inorder.size() - 1);
+    }
+private:
+    TreeNode* build(vector<int>& preorder, vector<int>& inorder, int& index, int i, int j) {
+        if (i > j) {
+            return NULL;
+        }
+        
+        TreeNode* root = new TreeNode(preorder[index]);
+        
+        int split = 0;
+        for (int i = 0; i < inorder.size(); i++) {
+            if (preorder[index] == inorder[i]) {
+                split = i;
+                break;
+            }
+        }
+        index++;
+        
+        root->left = build(preorder, inorder, index, i, split - 1);
+        root->right = build(preorder, inorder, index, split + 1, j);
+        
+        return root;
+    }
+};

cpp/11-Container-With-Most-Water.cpp

@@ -0,0 +1,33 @@
+/*
+    Given array of heights, find max water container can store
+    Ex. height = [1,8,6,2,5,4,8,3,7] -> 49, (8 - 1) x min(8, 7)
+
+    2 pointers outside in, greedily iterate pointer w/ lower height
+
+    Time: O(n)
+    Space: O(1)
+*/
+
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int i = 0;
+        int j = height.size() - 1;
+        
+        int curr = 0;
+        int result = 0;
+        
+        while (i < j) {
+            curr = (j - i) * min(height[i], height[j]);
+            result = max(result, curr);
+            
+            if (height[i] <= height[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        
+        return result;
+    }
+};