Taken Facebook 2nd phone interview. 3 problems asked and nailed it. More likely to pass this round and get invitation to onsite interviews :)

Author: kaidul

Diff for: README.md

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    int calPoints(vector<string>& ops) {
+        stack<int> Stack;
+        int sum = 0;
+        for(int i = 0; i < ops.size(); i++) {
+            if(ops[i] == "+") {
+                int a = Stack.top();
+                Stack.pop();
+                int b = Stack.top();
+                Stack.pop();
+                int c = a + b;
+                Stack.push(b); Stack.push(a); Stack.push(c);
+                sum += c;
+            } else if(ops[i] == "D") {
+                int top = Stack.top();
+                top <<= 1;
+                sum += top;
+                Stack.push(top);
+            } else if(ops[i] == "C") {
+                int top = Stack.top();
+                Stack.pop();
+                sum -= top;
+            } else {
+                int value = atoi(ops[i].c_str());
+                sum += value;
+                Stack.push(value);
+            }
+        }
+        return sum;
+    }
+};

Diff for: source-code/Baseball_Game.cpp

@@ -0,0 +1,30 @@
+/*
+// Employee info
+class Employee {
+public:
+    // It's the unique ID of each node.
+    // unique id of this employee
+    int id;
+    // the importance value of this employee
+    int importance;
+    // the id of direct subordinates
+    vector<int> subordinates;
+};
+*/
+class Solution {
+    int getImportance(int id, vector<Employee*> const& employees, unordered_map<int, int>& employeeMap) {
+        int totalImportance = employees[employeeMap[id]]->importance;
+        for(int subordinateId : employees[employeeMap[id]]->subordinates) {
+            totalImportance += getImportance(subordinateId, employees, employeeMap);
+        }
+        return totalImportance;
+    }
+public:
+    int getImportance(vector<Employee*> employees, int id) {
+        unordered_map<int, int> employeeMap;
+        for(int i = 0; i < employees.size(); i++) {
+            employeeMap[employees[i]->id] = i;
+        }
+        return getImportance(id, employees, employeeMap);
+    }
+};

Diff for: source-code/Employee_Importance.cpp

@@ -0,0 +1,96 @@
+class MagicDictionary {
+    class trie {
+        class trieNode {
+        public:
+            bool mark;
+            unordered_map<char, trieNode*> childrenMap;
+            trieNode(): mark(false) {
+                childrenMap = unordered_map<char, trieNode*>();
+            }
+            ~trieNode() {
+                for(auto it = childrenMap.begin(); it != childrenMap.end(); ++it) {
+                    delete it->second;
+                }
+                childrenMap = unordered_map<char, trieNode*>();
+            }
+        };
+        
+        bool search(int indx, int ignored, string const& key, trieNode* pCrawl) {
+            if(ignored > 1) {
+                return false;
+            }
+            if(indx == key.length() - 1) {
+                if(ignored == 0) {
+                    for(auto it = pCrawl->childrenMap.begin(); it != pCrawl->childrenMap.end(); ++it) {
+                        if(it->first != key[indx] and it->second->mark) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                return pCrawl->childrenMap.find(key[indx]) != pCrawl->childrenMap.end() 
+                        and pCrawl->childrenMap[key[indx]]->mark
+                        and ignored == 1;
+            }
+            for(auto it = pCrawl->childrenMap.begin(); it != pCrawl->childrenMap.end(); ++it) {
+                if(search(indx + 1, ignored + (it->first != key[indx]), key, it->second)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        
+        trieNode* root;
+        
+    public:
+        trie(): root(new trieNode()) {
+        }
+        
+        ~trie() {
+            // delete root;
+            root = nullptr;
+        }
+        
+        void insert(string const& key) {
+            trieNode* pCrawl = root;
+            for(int i = 0; i < key.length(); i++) {
+                if(pCrawl->childrenMap.find(key[i]) == pCrawl->childrenMap.end()) {
+                    pCrawl->childrenMap[key[i]] = new trieNode();
+                }
+                pCrawl = pCrawl->childrenMap[key[i]];
+            }
+            pCrawl->mark = true;
+        }
+        
+        bool search(string const& key) {
+            trieNode* pCrawl = root;
+            return search(0, 0, key, root);
+        }
+        
+    };
+public:
+    trie Trie;
+    /** Initialize your data structure here. */
+    MagicDictionary() {
+        Trie = trie();
+    }
+    
+    /** Build a dictionary through a list of words */
+    void buildDict(vector<string> dict) {
+        for(string const& key: dict) {
+            Trie.insert(key);
+        }
+    }
+    
+    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
+    bool search(string word) {
+        return Trie.search(word);
+    }
+};
+
+/**
+ * Your MagicDictionary object will be instantiated and called as such:
+ * MagicDictionary obj = new MagicDictionary();
+ * obj.buildDict(dict);
+ * bool param_2 = obj.search(word);
+ */

Diff for: source-code/Implement_Magic_Dictionary.cpp

@@ -0,0 +1,21 @@
+/**
+ * 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 {
+    int longestUnivaluePath(TreeNode* root, int val) {
+        if(!root or root->val != val) return 0;
+        return 1 + max(longestUnivaluePath(root->left, val), longestUnivaluePath(root->right, val));
+    }
+public:
+    int longestUnivaluePath(TreeNode* root) {
+        if(!root) return 0;
+        int sub = max(longestUnivaluePath(root->left), longestUnivaluePath(root->right));
+        return max(sub, longestUnivaluePath(root->left, root->val) + longestUnivaluePath(root->right, root->val));
+    }
+};

Diff for: source-code/Longest_Univalue_Path.cpp

@@ -0,0 +1,46 @@
+// there are at most 4 * 4 * 4b* 4 = 256 possible times only. So lets try them all
+class Solution {
+    void search(int indx, vector<int>& digits, string curr, string& result, int& diff, int const target) {
+        if(indx == 4) {
+            int total = atoi(curr.substr(0, 2).c_str()) * 60 + atoi(curr.substr(2).c_str());
+            if(total == target) {
+                return;
+            }
+            int currDiff = total - target > 0 ? total - target : 1440 + total - target;
+            if(currDiff < diff) {
+                diff = currDiff;
+                result = curr.substr(0, 2) + ":" + curr.substr(2);
+            }
+            return;
+        }
+        for(int i = 0; i < digits.size(); i++) {
+            if(indx == 0 and digits[i] > 2) { continue; }
+            if(indx == 1 and atoi(curr.c_str()) * 10 + digits[i] > 23) { continue; }
+            if(indx == 2 and digits[i] > 5) { continue; }
+            if(indx == 3 and atoi(curr.substr(2).c_str()) * 10 + digits[i] > 59) { continue; }
+            
+            search(indx + 1, digits, curr + to_string(digits[i]), result, diff, target);
+        }
+    }
+public:
+    string nextClosestTime(string time) {
+        vector<int> digits;
+        unordered_set<int> digitSet;
+        digitSet.insert(atoi(time.substr(0, 1).c_str()));
+        digitSet.insert(atoi(time.substr(1, 1).c_str()));
+        digitSet.insert(atoi(time.substr(3, 1).c_str()));
+        digitSet.insert(atoi(time.substr(4).c_str()));
+        if(digitSet.size() == 1) {
+            return time;
+        }
+        for(auto it = digitSet.begin(); it != digitSet.end(); ++it) {
+            digits.push_back(*it);
+        }
+        string result = "";
+        int target = atoi(time.substr(0, 2).c_str()) * 60 + atoi(time.substr(3).c_str());
+        int diff = INT_MAX;
+        search(0, digits, "", result, diff, target);
+        
+        return result;
+    }
+};

Diff for: source-code/Next_Closest_Time.cpp

@@ -0,0 +1,22 @@
+class Solution {
+    int find(int u, vector<int>& parent) {
+        return parent[u] != u ? parent[u] = find(parent[u], parent) : parent[u];
+    }
+public:
+    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
+        int n = edges.size();
+        vector<int> parent(n + 1);
+        for(int i = 1; i <= n; i++) {
+            parent[i] = i;
+        }
+        for(int i = 0; i < edges.size(); i++) {
+            int u = edges[i][0], v = edges[i][1];
+            u = find(u, parent), v = find(v, parent);
+            if(u == v) {
+                return edges[i];
+            }
+            parent[v] = u;
+        }
+        return vector<int>(2);
+    }
+};

Diff for: source-code/Redundant_Connection.cpp

@@ -0,0 +1,38 @@
+class Solution {
+    int find(int u, vector<int>& parent) {
+        return parent[u] != u ? parent[u] = find(parent[u], parent) : parent[u];
+    }
+public:
+    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
+        int n = edges.size();
+        vector<int> candidateA{-1, -1}, candidateB{-1, -1}; // edge pair pointing two parents for same node i.e. [2, 1], [3, 1]
+        vector<int> parent(n + 1, 0);
+        for(vector<int>& edge: edges) {
+            if(parent[edge[1]] == 0) {
+                parent[edge[1]] = edge[0];
+            } else {
+                candidateA = vector<int>{parent[edge[1]], edge[1]};
+                candidateB = edge;
+                edge[1] = 0;
+            }
+        }
+        for(int i = 0; i <= n; i++) {
+            parent[i] = i;
+        }
+        for(int i = 0; i < edges.size(); i++) {
+            int u = edges[i][0], v = edges[i][1];
+            if(v == 0) {
+                continue;
+            }
+            u = find(u, parent), v = find(v, parent);
+            if(u == v) {
+                if(candidateA[0] == -1) {
+                    return edges[i];    
+                }
+                return candidateA;
+            }
+            parent[v] = u;
+        }
+        return candidateB;
+    }
+};

Diff for: source-code/Redundant_Connection_II.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int repeatedStringMatch(string A, string B) {
+        for(int i = 0, j = 0; i < A.length(); ++i) {
+            for(j = 0; j < B.length() and A[(i + j) % A.length()] == B[j]; ++j);
+            if(j == B.length()) {
+                return (i + j) / A.length() + ((i + j) % A.length() != 0);    
+            }
+        }
+        return -1;
+    }
+};

Diff for: source-code/Repeated_String_Match.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int findUnsortedSubarray(vector<int>& nums) {
+        vector<int> numsSorted(nums);
+        sort(numsSorted.begin(), numsSorted.end());
+        int n = nums.size();
+        int left = 0, right = n - 1;
+        while(left < n and nums[left] == numsSorted[left]) {
+            left++;
+        }
+        while(right >= left and nums[right] == numsSorted[right]) {
+            right--;
+        }
+        return max(0, right - left + 1);
+    }
+};