532/602 solved. Progressed to Amazon web services SDE onsite-interview stage

Author: kaidul

source-code/Add_One_Row_to_Tree.cpp

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+    void addOneRow(TreeNode* curr, int depth, const int v, const int d) {
+        if(depth == d - 1) {
+            TreeNode* left = curr->left;
+            curr->left = new TreeNode(v);
+            curr->left->left = left;
+            TreeNode* right = curr->right;
+            curr->right = new TreeNode(v);
+            curr->right->right = right;
+            return;
+        }
+        if(curr->left) addOneRow(curr->left, depth + 1, v, d);
+        if(curr->right) addOneRow(curr->right, depth + 1, v, d);
+    }
+public:
+    TreeNode* addOneRow(TreeNode* root, int v, int d) {
+        if(d == 1) {
+            TreeNode* newRoot = new TreeNode(v);
+            newRoot->left = root;
+            return newRoot;
+        }
+        addOneRow(root, 1, v, d);
+        return root;
+    }
+};

source-code/Find_the_Duplicate_Number.cpp

@@ -0,0 +1,24 @@
+class Solution {
+    int countNumbers(vector<int> const& nums, int mid) {
+        int cnt = 0;
+        for(int i = 0; i < nums.size(); ++i) {
+            cnt += (nums[i] <= mid);
+        }
+        return cnt;
+    }
+public:
+    int findDuplicate(vector<int>& nums) {
+        if(nums.empty()) return 0;
+        int left = 0, right = nums.size() - 1;
+        while(left < right) {
+            int mid = left + (right - left) / 2;
+            int cnt = countNumbers(nums, mid);
+            if(cnt <= mid) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+};

source-code/Maximum_Distance_in_Arrays.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    int maxDistance(vector<vector<int>>& arrays) {
+        int left = arrays[0][0], right = arrays[0].back();
+        int ans = 0;
+        for(int i = 1; i < (int)arrays.size(); i++) {
+            ans = max(ans, max(abs(arrays[i][0] - right), abs(arrays[i].back() - left)));
+            left = min(left, arrays[i][0]);
+            right = max(right, arrays[i].back());
+        }
+        return ans;
+    }
+};

source-code/Merge_Two_Binary_Trees.cpp

@@ -0,0 +1,22 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
+        if(!t1 and !t2) {
+            return nullptr;
+        }
+        TreeNode* currNode = new TreeNode((t1 ? t1->val : 0) + (t2 ? t2->val : 0));
+        currNode->left = mergeTrees((t1 ? t1->left : nullptr), (t2 ? t2->left : nullptr));
+        currNode->right = mergeTrees((t1 ? t1->right : nullptr), (t2 ? t2->right : nullptr));
+        
+        return currNode;
+    }
+};

source-code/Minimum_Factorization.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int smallestFactorization(int a) {
+        if(a < 10) { return a; }
+        int factors[40];
+        int i = 0;
+        for(int d = 9; d > 1; d--) {
+            while(a % d == 0) {
+                a /= d;
+                factors[i++] = d;
+            }
+        }
+        if(a > 10) {
+            return 0;
+        }
+        long long result = 0LL;
+        for(int k = i - 1; k >= 0; k--) {
+            result = result * 10 + factors[k];
+            if(result > INT_MAX) { return 0; }
+        }
+        return (int)result;
+    }
+};

source-code/Minimum_Number_of_Arrows_to_Burst_Balloons.cpp

@@ -4,16 +4,16 @@ class Solution {
         if(points.empty()) return 0;
         sort(points.begin(), points.end());
         int n = points.size();
-        int balloons = 0;
+        int arrows = 0;
         for(int i = 0; i < n; ++i) {
             int boundary = points[i].second;
             while(i + 1 < n and points[i + 1].first <= boundary) {
                 boundary = min(boundary, points[i + 1].second);
                 ++i;
             }
-            balloons++;
+            arrows++;
         }
 
-        return balloons;
+        return arrows;
     }
 };

source-code/Task_Scheduler.cpp

@@ -0,0 +1,35 @@
+// round robin
+class Solution {
+public:
+    int leastInterval(vector<char>& tasks, int n) {
+        unordered_map<char, int> taskFreq;
+        for (char task : tasks) {
+            taskFreq[task]++;
+        }
+        priority_queue<pair<int, char>> pQ;
+        for (pair<char, int> taskCount : taskFreq) {
+            pQ.push({taskCount.second, taskCount.first});
+        }
+        int interval = 0;
+        int cycle = n + 1;
+        while(!pQ.empty()) {
+            int tasks = 0;
+            vector<pair<int, char>> tmp;
+            for(int i = 0; i < cycle; i++) {
+                if(!pQ.empty()) {
+                    tmp.push_back(pQ.top());
+                    pQ.pop();
+                    tasks++;
+                }
+            }
+            for(auto task : tmp) {
+                if(--task.first) {
+                    pQ.push(task);
+                }
+            }
+            interval += !pQ.empty() ? cycle : tasks;
+        }
+        return interval;
+        
+    }
+};

source-code/Valid_Triangle_Number.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    int triangleNumber(vector<int>& nums) {
+        int n = (int)nums.size();
+        if(n <= 2) return 0;
+        int count = 0;
+        sort(nums.begin(), nums.end());
+        int offset = 0;
+        while(offset < n and nums[offset] == 0) { offset++; }
+        for(int i = n - 1; i >= offset + 2; i--) {
+            int a = nums[i];
+            for(int j = i - 1; j >= offset + 1; j--) {
+                int b = nums[j];
+                int left = offset, right = j - 1;
+                int cIndx = -1;
+                while(left <= right) {
+                    int mid = left + (right - left) / 2;
+                    if(nums[mid] + b > a) {
+                        cIndx = mid;
+                        right = mid - 1;
+                    } else if(nums[mid] + b <= a) {
+                        left = mid + 1;
+                    }
+                }
+                if(cIndx != -1) {
+                    count += (j - cIndx);
+                }
+            }
+        }
+        return count;
+    }
+};

source-code/Wiggle_Subsequence.cpp

@@ -1,3 +1,4 @@
+// O(n^2) dynamic programming
 class Solution {
 public:
     int wiggleMaxLength(vector<int>& nums) {
@@ -19,4 +20,46 @@ class Solution {
 
         return maxLength;
     }
+};
+
+// O(n) dp
+class Solution {
+public:
+    int wiggleMaxLength(vector<int>& nums) {
+        int n = (int)nums.size();
+        if(n == 0) return n;
+        vector<int> down(n, 0), up(n, 0);
+        down[0] = up[0] = 1;
+        for(int i = 1; i < n; ++i) {
+            if(nums[i] > nums[i - 1]) {
+                up[i] = down[i - 1] + 1;
+                down[i] = down[i - 1];
+            } else if(nums[i] < nums[i - 1]) {
+                up[i] = up[i - 1];
+                down[i] = up[i - 1] + 1;
+            } else {
+                up[i] = up[i - 1];
+                down[i] = down[i - 1];
+            }
+        }
+        return max(up[n - 1], down[n - 1]);
+    }
+};
+
+// O(n) greedy
+class Solution {
+public:
+    int wiggleMaxLength(vector<int>& nums) {
+        int n = (int)nums.size();
+        if(n == 0) return 0;
+        int up = 1, down = 1;
+        for(int i = 1; i < n; ++i) {
+            if(nums[i] > nums[i - 1]) {
+                up = down + 1;
+            } else if(nums[i] < nums[i - 1]) {
+                down = up + 1;
+            }
+        }
+        return max(up, down);
+    }
 };