Just get into Agoda.com recruitment process today, after the recruiter found me via Linkedin. Updated Linkedin profile few days back so expecting more surprise knock.

Author: kaidul

Diff for: source-code/Beautiful_Arrangement_II.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    vector<int> constructArray(int n, int k) {
+        vector<int> result;
+        if(k > n - 1) {
+            return result;
+        }
+        int left = 1, right = n;
+        for(int i = 0, flip = 0; i < n; i++, flip ^= 1) {
+            if(k == 1) {
+                if(flip) {
+                    for(int i = right; i >= left; i--) {
+                        result.push_back(i);
+                    }
+                } else {
+                    for(int i = left; i <= right; i++) {
+                        result.push_back(i);
+                    }
+                }
+                break;
+            }
+            if(i > 0) { k--; }
+            result.push_back(flip ? left++ : right--);
+        }
+        return result;
+    }
+};

Diff for: source-code/Find_Duplicate_Subtrees.cpp

@@ -0,0 +1,93 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+// AC
+// postorder and preorder signature will work, inorder not.
+class Solution {
+    string preorder(TreeNode* root, unordered_map<string, int>& preOrderMap, vector<TreeNode*>& result) {
+        if(!root) {
+            return "#";
+        }
+        signature += "," + to_string(root->val);
+        string signature = preorder(root->left, preOrderMap, result);
+        signature += "," + preorder(root->right, preOrderMap, result);
+        // signature += "," + to_string(root->val); would work too
+        
+        if(preOrderMap[signature] == 1) {
+            result.push_back(root);
+        }
+        preOrderMap[signature]++;
+        return signature;
+    }
+public:
+    vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
+        vector<TreeNode*> result;
+        unordered_map<string, int> preOrderMap;
+        preorder(root, preOrderMap, result);
+        return result;
+    }
+};
+
+// brute-force, TLE, 121/167 testcases passed
+class Solution {
+    bool isSame(TreeNode* rootA, TreeNode* rootB) {
+        if(!rootA and !rootB) {
+            return true;
+        }
+        if(!rootA or !rootB) {
+            return false;
+        }
+        return rootA->val == rootB->val and isSame(rootA->left, rootB->left) and isSame(rootA->right, rootB->right);
+    }
+    
+    bool hasDuplicate(TreeNode* node, TreeNode* root, unordered_set<TreeNode*>& visited) {
+        if(!root) {
+            return false;
+        }
+        if(visited.find(root) == visited.end() and isSame(node, root)) {
+            visited.insert(root);
+            return true;
+        }
+        int leftDuplicate = hasDuplicate(node, root->left, visited);
+        int rightDuplicate = hasDuplicate(node, root->right, visited);
+        
+        return leftDuplicate or rightDuplicate;
+    }
+    
+    void findDuplicateSubtrees(TreeNode* node, TreeNode* root, vector<TreeNode*>& result, unordered_set<TreeNode*>& visited) {
+        if(!node) {
+            return;
+        }
+        if(visited.find(node) == visited.end()) {
+            visited.insert(node);
+            if(hasDuplicate(node, root, visited)) {
+                result.push_back(node);
+            }
+        }
+        
+        findDuplicateSubtrees(node->left, root, result, visited);
+        findDuplicateSubtrees(node->right, root, result, visited);
+    }
+public:
+    vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
+        unordered_set<TreeNode*> visited;
+        vector<TreeNode*> result;
+        findDuplicateSubtrees(root, root, result, visited);
+        return result;
+    }
+};

Diff for: source-code/Kth_Smallest_Number_in_Multiplication_Table.cpp

@@ -0,0 +1,22 @@
+class Solution {
+    bool largerEnough(int x, int m, int n, int k) {
+        int count = 0;
+        for(int i = 1; i <= m; i++) {
+            count += min(x / i, n);
+        }
+        return count >= k;
+    }
+public:
+    int findKthNumber(int m, int n, int k) {
+        int left = 1, right = m * n;
+        while(left < right) {
+            int mid = left + (right - left) / 2;
+            if(!largerEnough(mid, m, n, k)) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+};

Diff for: source-code/Non-decreasing_Array.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    bool checkPossibility(vector<int>& nums) {
+        int changed = 0;
+        for(int i = 0; i < nums.size() - 1; i++) {
+            if(nums[i] > nums[i + 1]) {
+                if(changed > 0) {
+                    return false;
+                }
+                if(i - 1 >= 0) {
+                    if(nums[i + 1] >= nums[i - 1]) {
+                        nums[i] = nums[i - 1];
+                    } else if(nums[i + 1] < nums[i - 1]) {
+                        nums[i + 1] = nums[i];
+                    }
+                } else {
+                    nums[i] = nums[i + 1]; 
+                }
+                ++changed;
+            }
+        }
+        return true;
+    }
+};

Diff for: source-code/Subtree_of_Another_Tree.cpp

@@ -19,4 +19,39 @@ class Solution {
         if(s == nullptr) return false;
         return isSameTree(s, t) or isSubtree(s->left, t) or isSubtree(s->right, t);
     }
+};
+
+// using preorder hash
+class Solution {
+    string preorderHash(TreeNode* root) {
+        if(!root) {
+            return "#";
+        }
+        return to_string(root->val)
+                + "," + preorderHash(root->left)
+                + "," + preorderHash(root->right);
+    }
+    
+    string checkSubtree(TreeNode* root, string const& signature, bool& isSubtree) {
+        if(!root) {
+            return "#";
+        }
+        if(isSubtree) {
+            return "";
+        }
+        string preorder = to_string(root->val);
+        preorder += "," + checkSubtree(root->left, signature, isSubtree);
+        preorder += "," + checkSubtree(root->right, signature, isSubtree);
+        if(preorder == signature) {
+            isSubtree = true;
+        }
+        return preorder;
+    }
+public:
+    bool isSubtree(TreeNode* s, TreeNode* t) {
+        string signature = preorderHash(t);
+        bool isSubtree = false;
+        checkSubtree(s, signature, isSubtree);
+        return isSubtree;
+    }
 };