More code solution

Author: andy2git

Balanced_Binary_Tree.cpp

@@ -0,0 +1,35 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool isBalanced(TreeNode *root) {
+        if(root == nullptr) return true;
+        
+        int h = is_balanced(root);
+        
+        if(h < 0) return false;
+        return true;
+    }
+private:
+    int is_balanced(TreeNode *root){
+        if(root == nullptr) return 0;
+        if(root->left == nullptr && root->right == nullptr) return 1;
+        
+        int left = is_balanced(root->left);
+        if(left < 0) return -1;
+        
+        int right = is_balanced(root->right);
+        if(right < 0) return -1;
+        
+        if(abs(left-right) > 1) return -1;
+        else return max(left, right)+1;
+    }
+    
+};

Binary_Tree_Inorder_Traversal.cpp

@@ -0,0 +1,34 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<int> inorderTraversal(TreeNode *root) {
+        if(root == nullptr) return vector<int>();
+        
+        vector<int> result;
+        stack<TreeNode *> st;
+        TreeNode *p = root;
+        
+        while(p || !st.empty()){
+            if(p){
+                st.push(p);
+                p = p->left;
+            }else{
+                p = st.top();
+                st.pop();
+        
+                result.push_back(p->val);        
+                p = p->right;
+            }
+        }
+        
+        return result;
+    }
+};

Binary_Tree_Maximum_Path_Sum.cpp

@@ -0,0 +1,52 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+class Solution {
+public:
+    int maxPathSum(TreeNode *root) {
+        int max_sum = INT_MIN;
+        
+        max_path_sum_helper(root, max_sum);
+        
+        return max_sum;
+    }
+    
+private:
+    int max_path_sum_helper(TreeNode *root, int &max_sum){
+        if(root == nullptr) return 0;
+        // NOT NEEDED - STILL NEED TO CHECK IF IT IS THE MAX_SUM
+        // if(root->left == nullptr && root->right == nullptr) return root->val;
+        
+        //if(root->left == nullptr && root->right == nullptr){
+        //    if(root->val > max_sum) max_sum = root->val;
+        //    return root->val;  
+        //} 
+        
+        int left = max_path_sum_helper(root->left, max_sum);
+        int right = max_path_sum_helper(root->right, max_sum);
+        
+        // one option for max path sum
+        int sum = root->val;
+        if(left > 0) sum +=left;
+        if(right > 0) sum += right;
+        if(sum > max_sum){
+            max_sum = sum;
+        }
+        
+        //max path with the root node included for the upper level
+        return max(root->val, max(root->val+left, root->val+right));
+    }
+};
+
+/* OBSERVATION:
+ * Any max path has to go through a 'root' node, so recursivly go 
+ * all the way into the bottom, and the max value will be one of 
+ * the potential path with the internal node.
+ */

Binary_Tree_Preorder_Traversal.cpp

@@ -0,0 +1,31 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<int> preorderTraversal(TreeNode *root) {
+        if(root == nullptr) return vector<int>();
+        
+        vector<int> result;
+        stack<TreeNode *> st;
+        st.push(root);
+        
+        TreeNode *p = nullptr;
+        while(!st.empty()){
+            p = st.top();
+            st.pop();
+            
+            result.push_back(p->val);
+            if(p->right) st.push(p->right);
+            if(p->left) st.push(p->left);
+        }
+        
+        return result;
+    }
+};

Climbing_Stairs.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int climbStairs(int n) {
+        if(n <= 2) return n;
+        
+        int first = 1;
+        int second = 2;
+        int third;
+        while(n > 2){
+            third = first+second;
+            first = second;
+            second = third;
+            n--;
+        }
+        return second;
+    }
+};

Flatten_Binary_Tree_to_Linked_List.cpp

@@ -0,0 +1,37 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void flatten(TreeNode *root) {
+        if(root == nullptr) return;
+        if(root->left == nullptr && root->right == nullptr) return;
+        
+        stack<TreeNode *> st;
+        st.push(root);
+        TreeNode *p = nullptr;
+        TreeNode *pre = nullptr;
+        
+        while(!st.empty()){
+            p = st.top();
+            st.pop();
+            
+            if(pre){
+                pre->left = nullptr;
+                pre->right = p;
+            }
+            pre = p;
+            
+            if(p->right) st.push(p->right);
+            if(p->left) st.push(p->left);
+        }
+        
+        pre->left = pre->right = nullptr;
+    }
+};

Four_Sum_Closest.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+    vector<vector<int> > fourSum(vector<int> &num, int target) {
+        vector<vector<int>> solution;
+        set<vector<int>> unique;
+        
+        if(num.size() < 4) return solution;
+        
+        sort(num.begin(), num.end());
+        
+        for(int i = 0; i < num.size()-3; i++){
+            for(int j = i+1; j < num.size(); j++){
+                
+                int p = j+1;
+                int q = num.size()-1;
+                
+                while(p < q){
+                    if(num[i]+num[j]+num[p]+num[q] == target){
+                        unique.insert({num[i], num[j], num[p], num[q]});
+                        p++;
+                        q--;
+                    }else if(num[i]+num[j]+num[p]+num[q] > target){
+                        q--;
+                    }else{
+                        p++;
+                    }
+                }
+            }
+        }
+        
+        for(auto it = unique.begin(); it != unique.end(); ++it){
+            solution.push_back(*it);
+        }
+        
+        return solution;
+    }
+};

LRU_Cache.cpp

@@ -0,0 +1,52 @@
+class LRUCache{
+private:
+    int size;
+    int cap;
+    unordered_map<int, list<pair<int, int>>::iterator> map;
+    list<pair<int, int>> lst;
+    
+    void update(int key, int val){
+        auto it = map[key];
+        pair<int, int> t = {key, val};
+        lst.erase(it);
+        lst.push_front(t);
+        map[key] = lst.begin();
+    }
+    
+    void remove_least(){
+        pair<int, int> t = lst.back();
+        lst.pop_back();
+        map.erase(t.first);
+        size--;
+    }
+    
+    void insert(int key, int val){
+        lst.push_front({key, val});
+        map[key] = lst.begin();
+        size++;
+    }
+    
+public:
+    LRUCache(int capacity) {
+        cap = capacity;
+        size = 0;
+    }
+    
+    int get(int key) {
+        if(map.find(key) == map.end()) return -1;
+        int val = map[key]->second;
+        update(key, val);
+        return val;
+    }
+
+    void set(int key, int value) {
+        if(map.find(key) != map.end()){
+            update(key, value);
+        }else{
+            if(size == cap){
+                 remove_least();   
+            }
+            insert(key, value);
+        }
+    }
+};

Longest_Consecutive_Sequence.cpp

@@ -0,0 +1,43 @@
+class Solution {
+public:
+    int longestConsecutive(vector<int> &num) {
+        if(num.empty()) return 0;
+        if(num.size() == 1) return 1;
+        
+        unordered_map<int, bool> map;
+        for(int i = 0; i < num.size(); i++){
+            map[num[i]] = false;
+        }
+        
+        int max_len = INT_MIN;
+        int len;
+        int p;
+        for(int i = 0; i < num.size(); i++){
+            if(map[num[i]]) continue;
+
+            len = 1;
+            map[num[i]] = true;
+            
+            // search the increasing direction
+            p = num[i]+1;
+            while(map.find(p) != map.end()){
+                len++;
+                map[p] = true;
+                p++;
+            }
+            // search the decreasing direction
+            p = num[i]-1;
+            while(map.find(p) != map.end()){
+                len++;
+                map[p] = true;
+                p--;
+            }
+            
+            if(len > max_len){
+                max_len = len;
+            }
+        }
+        
+        return max_len;
+    }
+};

Minimum_Depth_of_Binary_Tree.cpp

@@ -0,0 +1,29 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    int minDepth(TreeNode *root) {
+        if(root == nullptr) return 0;
+        
+        if(root->left && root->right) return min(minDepth(root->left), minDepth(root->right))+1;
+        else if(root->left == nullptr && root->right) return minDepth(root->right)+1;
+        else if(root->left && root->right == nullptr) return minDepth(root->left)+1;
+        else return 1;
+    }
+};
+
+/**
+ * Watch out for internal node with only one child
+ * There are four cases for a node:
+ * 1. left and right
+ * 2. left
+ * 3. right
+ * 4. leaf node
+ */

Minimum_Path_Sum.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int minPathSum(vector<vector<int> > &grid) {
+        int m = grid.size();
+        int n = grid[0].size();
+        
+        for(int i = 1; i < m; i++){
+            grid[i][0] += grid[i-1][0];
+        }
+        
+        for(int j = 1; j < n; j++){
+            grid[0][j] += grid[0][j-1];
+        }
+        
+        for(int i = 1; i < m; i++){
+            for(int j = 1; j < n; j++){
+                grid[i][j] += min(grid[i-1][j], grid[i][j-1]);
+            }
+        }
+        return grid[m-1][n-1];
+    }
+};