554/656 problems solved. Facebook Data Engineer phone interview passed. Waiting for possible onsite interview invitation.

kaidul · kaidul · commit 1ab0cfa5842e · 2017-09-21T18:19:11.000+06:00
diff --git a/README.md b/README.md
diff --git a/source-code/Longest_Continuous_Increasing_Subsequence.cpp b/source-code/Longest_Continuous_Increasing_Subsequence.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int findLengthOfLCIS(vector<int>& nums) {
+        int maxLen = 0;
+        int i = 0;
+        while(i < nums.size()) {
+            int currLen = 0;
+            int prev = nums[i++];
+            currLen++;
+            while(i < nums.size() and nums[i] > prev) {
+                prev = nums[i++];
+                currLen++;
+            }
+            maxLen = max(maxLen, currLen);
+        }
+        return maxLen;
+    }
+};
diff --git a/source-code/Map_Sum_Pairs.cpp b/source-code/Map_Sum_Pairs.cpp
@@ -0,0 +1,78 @@
+class MapSum {
+    class Trie {
+        class trieNode {
+        public:
+            int value;
+            int sum;
+            unordered_map<char, trieNode*> children;
+            trieNode(): value(0), sum(0) {
+                children = unordered_map<char, trieNode*>();
+            }
+            trieNode(int value): value(value), sum(value) {
+                children = unordered_map<char, trieNode*>();
+            }
+        };
+        
+        int insert(int indx, string const& key, const int value, trieNode* pCrawl) {
+            if(indx == key.length() - 1) {
+                if(pCrawl->children.find(key[indx]) == pCrawl->children.end()) {
+                    pCrawl->children[key[indx]] = new trieNode(value);
+                    return value;
+                }
+                int oldValue = pCrawl->children[key[indx]]->value;
+                pCrawl->children[key[indx]]->value = value;
+                pCrawl->children[key[indx]]->sum += value;
+                pCrawl->children[key[indx]]->sum -= oldValue;
+                return value - oldValue;    
+            }
+            if(pCrawl->children.find(key[indx]) == pCrawl->children.end()) {
+                pCrawl->children[key[indx]] = new trieNode();
+            }
+            int deltaSum = insert(indx + 1, key, value, pCrawl->children[key[indx]]);
+            
+            pCrawl->children[key[indx]]->sum += deltaSum;
+            
+            return deltaSum;
+        }
+        
+        trieNode* root;
+    public:
+        Trie(): root(new trieNode()) {}
+        
+        int query(string const& key) {
+            trieNode* pCrawl = root;
+            for(int i = 0; i < key.length(); i++) {
+                if(pCrawl->children.find(key[i]) == pCrawl->children.end()) {
+                    return 0;
+                }
+                pCrawl = pCrawl->children[key[i]];
+            }
+            return pCrawl->sum;
+        }
+        
+        void insert(string const& key, int const value) {
+            insert(0, key, value, root);
+        }
+    };
+    Trie* trie;
+public:
+    /** Initialize your data structure here. */
+    MapSum() {
+        trie = new Trie();
+    }
+    
+    void insert(string key, int val) {
+        trie->insert(key, val);
+    }
+    
+    int sum(string prefix) {
+        return trie->query(prefix);
+    }
+};
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * MapSum obj = new MapSum();
+ * obj.insert(key,val);
+ * int param_2 = obj.sum(prefix);
+ */
diff --git a/source-code/Reverse_Pairs.cpp b/source-code/Reverse_Pairs.cpp
@@ -0,0 +1,123 @@
+// AC
+class Solution {
+    int countReversePair(vector<int>& A, int start, int mid, int end) {
+        int j = mid + 1;
+        int count = 0;
+        for (int i = start; i <= mid; i++) {
+            while (j <= end and A[i] > 2LL * A[j]) {
+                j++;
+            }
+            count += j - (mid + 1);
+        }
+        return count;
+    }
+    
+    void merge(vector<int>& A, int start, int mid, int end) {
+        int n1 = (mid - start + 1);
+        int n2 = (end - mid);
+        int L[n1], R[n2];
+        
+        for (int i = 0; i < n1; i++) {
+            L[i] = A[start + i];
+        }
+        for (int j = 0; j < n2; j++) {
+            R[j] = A[mid + 1 + j];    
+        }
+        int i = 0, j = 0, k = start;
+        while(i < n1 and j < n2) {
+            if(L[i] < R[j]) {
+                A[k++] = L[i++];
+            } else {
+                A[k++] = R[j++];
+            }
+        }
+        while(i < n1) {
+            A[k++] = L[i++];
+        }
+        while(j < n2) {
+            A[k++] = R[j++];
+        }
+    }
+
+    int mergesortAndCount(vector<int>& A, int start, int end) {
+        if (start > end) {
+            return 0;
+        }
+        int mid = start + (end - start) / 2;
+        int count = mergesortAndCount(A, start, mid) + mergesortAndCount(A, mid + 1, end);
+        count += countReversePair(A, start, mid, end);
+        merge(A, start, mid, end);
+        
+        return count;
+    }
+
+public:
+    int reversePairs(vector<int>& nums) {
+        return mergesortAndCount(nums, 0, nums.size() - 1);
+    }
+
+};
+
+// TLE (for skewed binary tree)
+class Solution {
+    class BST {
+    public:
+        class BSTNode {
+        public:
+            BSTNode* left;
+            BSTNode* right;
+            int value;
+            int largerElemCount;
+            BSTNode(int value) {
+                this->value = value;
+                left = right = nullptr;
+                largerElemCount = 1;
+            }
+        };
+        BST(): root(nullptr) {}
+
+        int search(long long const key, BSTNode* curr) {
+            if(!curr) {
+                return 0;
+            }
+            if(curr->value == key) {
+                return curr->largerElemCount;
+            }
+            if(curr->value > key) {
+                return curr->largerElemCount + search(key, curr->left);
+            } else {
+                return search(key, curr->right);
+            }
+        }
+
+        BSTNode* insert(int const value, BSTNode* curr) {
+            if(!curr) {
+                return new BSTNode(value);
+            }
+            if(curr->value == value) {
+                curr->largerElemCount++;
+                return curr;
+            }
+            if(curr->value > value) {
+                curr->left = insert(value, curr->left);
+            }else {
+                curr->largerElemCount++;
+                curr->right = insert(value, curr->right);
+            }
+            return curr;
+        }
+        
+        BSTNode* root;
+    };
+    
+public:
+    int reversePairs(vector<int>& nums) {
+        int result = 0;
+        BST* bst = new BST();
+        for(int i = 0; i < nums.size(); i++) {
+            result += bst->search(2LL * nums[i] + 1LL, bst->root);
+            bst->root = bst->insert(nums[i], bst->root);
+        }
+        return result;
+    }
+};
diff --git a/source-code/Second_Minimum Node_In_a_Binary_Tree.cpp b/source-code/Second_Minimum Node_In_a_Binary_Tree.cpp
@@ -0,0 +1,32 @@
+/**
+ * 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 findSecondMinimumValue(TreeNode* root, const int minimum, int& secondMinimum) {
+        if(!root) return;
+        
+        if(root->val > minimum) {
+            secondMinimum = (secondMinimum != -1) ? min(secondMinimum, root->val) : root->val;
+        }
+        
+        if(root->right != nullptr and root->right->val > root->val) {
+            secondMinimum = (secondMinimum != -1) ? min(secondMinimum, root->right->val) : root->right->val;
+        } else {
+            findSecondMinimumValue(root->right, minimum, secondMinimum);    
+        }
+        
+        findSecondMinimumValue(root->left, minimum, secondMinimum);
+    }
+public:
+    int findSecondMinimumValue(TreeNode* root) {
+        int secondMinimum = -1;
+        findSecondMinimumValue(root, root->val, secondMinimum);
+        return secondMinimum;
+    }
+};
diff --git a/source-code/Subtree_of_Another_Tree.cpp b/source-code/Subtree_of_Another_Tree.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 {
+    bool isSameTree(TreeNode* s, TreeNode* t) {
+        if(!s and !t) return true;
+        if(!s or !t) return false;
+        return s->val == t->val and isSameTree(s->left, t->left) and isSameTree(s->right, t->right);    
+    }
+    
+public:
+    bool isSubtree(TreeNode* s, TreeNode* t) {
+        if(s == nullptr) return false;
+        return isSameTree(s, t) or isSubtree(s->left, t) or isSubtree(s->right, t);
+    }
+};
diff --git a/source-code/Valid_Palindrome_II.cpp b/source-code/Valid_Palindrome_II.cpp
@@ -0,0 +1,22 @@
+class Solution {
+    bool isPalindrome(string s, int left, int right) {
+        while(left < right) {
+            if(s[left] != s[right]) {
+                return false;
+            }
+            ++left, --right;
+        }
+        return true;
+    }
+public:
+    bool validPalindrome(string s) {
+        int left = 0, right = s.length() - 1;
+        while(left <= right and s[left] == s[right]) {
+            ++left, --right;
+        }
+        if(left >= right) {
+            return true;
+        }
+        return isPalindrome(s, left + 1, right) or isPalindrome(s, left, right - 1);
+    }
+};
diff --git a/source-code/Valid_Parenthesis_String.cpp b/source-code/Valid_Parenthesis_String.cpp
