More solutions added

Author: andy2git

Clone_Graph.cpp

@@ -0,0 +1,93 @@
+/**
+ * Definition for undirected graph.
+ * struct UndirectedGraphNode {
+ *     int label;
+ *     vector<UndirectedGraphNode *> neighbors;
+ *     UndirectedGraphNode(int x) : label(x) {};
+ * };
+ *
+ * 
+ * Solution: this clone is based on the edge instead of the node. 
+ *           This way will make sure the edge will be copied to the
+ *           cloned graph as well.
+ *
+ */
+class Solution {
+public:
+    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
+        if(node == nullptr) return nullptr;
+        
+        unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> map;
+        stack<UndirectedGraphNode *> st;
+        UndirectedGraphNode *t = nullptr;
+        UndirectedGraphNode *nGraph = new UndirectedGraphNode(node->label);
+        map[node] = nGraph;
+        
+        st.push(node);
+        while(!st.empty()){
+            t = st.top();
+            st.pop();
+            
+            for(int i = 0; i < t->neighbors.size(); i++){
+                UndirectedGraphNode *nb = t->neighbors[i];
+                if(map.find(nb) == map.end()){
+                    UndirectedGraphNode *x = new UndirectedGraphNode(nb->label);
+                    map[nb] = x;
+                    map[t]->neighbors.push_back(x);
+                    st.push(nb);
+                }else{
+                    map[t]->neighbors.push_back(map[nb]);
+                }
+            }
+        }
+        
+        return nGraph;
+    }
+};
+
+
+/**
+ * Definition for undirected graph.
+ * struct UndirectedGraphNode {
+ *     int label;
+ *     vector<UndirectedGraphNode *> neighbors;
+ *     UndirectedGraphNode(int x) : label(x) {};
+ * };
+ * 
+ * 
+ * BFS based solution.
+ * It is almost identical to the DFS solution except the order of edge copying is different from DFS.
+ * DFS will make go deeper and deeper, while BFS will copy edges layer by layer.
+ */
+class Solution {
+public:
+    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
+        if(node == nullptr) return nullptr;
+        
+        unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> map;
+        queue<UndirectedGraphNode *> st;
+        UndirectedGraphNode *t = nullptr;
+        UndirectedGraphNode *nGraph = new UndirectedGraphNode(node->label);
+        map[node] = nGraph;
+        
+        st.push(node);
+        while(!st.empty()){
+            t = st.front();
+            st.pop();
+            
+            for(int i = 0; i < t->neighbors.size(); i++){
+                UndirectedGraphNode *nb = t->neighbors[i];
+                if(map.find(nb) == map.end()){
+                    UndirectedGraphNode *x = new UndirectedGraphNode(nb->label);
+                    map[nb] = x;
+                    map[t]->neighbors.push_back(x);
+                    st.push(nb);
+                }else{
+                    map[t]->neighbors.push_back(map[nb]);
+                }
+            }
+        }
+        
+        return nGraph;
+    }
+};

Maximum_Subarray.cpp

@@ -0,0 +1,76 @@
+class Solution {
+public:
+    int maxSubArray(int A[], int n) {
+        int sum = 0;
+        int max_sum = A[0]; // contain at least one element
+        
+        for(int i = 0; i < n ; i++){
+            sum += A[i];
+            // make sure every elememt is compared
+            if(sum > max_sum){
+                max_sum = sum;
+            }
+            
+            if(sum < 0){
+                sum = 0;
+            }
+        }
+        return max_sum;
+    }
+};
+
+
+/* Divide and conquer solution */
+
+class Solution {
+public:
+    int maxSubArray(int A[], int n) {
+
+        int max_sum;
+        max_sum = max_sub_helper(A, 0, n);
+        
+        return max_sum;
+    }
+private:
+    
+    int max_sub_helper(int A[], int sInd, int eInd){
+        if (sInd+1 == eInd) return A[sInd];    // one elem array
+        if (sInd >= eInd) return INT_MIN;            // empty array
+        
+        int l_max, r_max, c_max;
+        int mInd;
+        
+        mInd = sInd + (eInd-sInd)/2;
+        
+        l_max = max_sub_helper(A, sInd, mInd);
+        r_max = max_sub_helper(A, mInd+1, eInd);
+        
+        
+        c_max = A[mInd];
+        
+        int prefix_sum = 0;
+        int prefix_max = INT_MIN;
+        
+        for (int i = mInd+1; i < eInd; i++) {
+            prefix_sum += A[i];
+            if (prefix_sum > prefix_max) prefix_max = prefix_sum;
+        }
+        
+        if (prefix_max > 0) {
+            c_max += prefix_max;
+        }
+        
+        int suffix_sum = 0;
+        int suffix_max = INT_MIN;
+        for (int i = mInd-1; i >= 0; i--) {
+            suffix_sum += A[i];
+            if (suffix_sum > suffix_max) suffix_max = suffix_sum;
+        }
+        
+        if (suffix_max > 0) {
+            c_max += suffix_max;
+        }
+        
+        return max(max(l_max, r_max), c_max);
+    }
+};

Merge_Sorted_Array.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    void merge(int A[], int m, int B[], int n) {
+        int k = m+n-1;
+        int i = m-1;
+        int j = n-1;
+        
+        while(i >= 0 && j >= 0){
+            if(A[i] > B[j]){
+                A[k--] = A[i--];
+            }else{
+                A[k--] = B[j--];
+            }
+        }
+        
+        while(j >= 0){
+            A[k--] = B[j--];
+        }
+    }
+};

Merge_Two_Sorted_Lists.cpp

@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
+        ListNode dummy(0);
+        ListNode *d = &dummy;
+        
+        while(l1 && l2){
+            if(l1->val < l2->val){
+                d->next = l1;
+                d = d->next;
+                l1 = l1->next;
+            }else{
+                d->next = l2;
+                d = d->next;
+                l2 = l2->next;
+            }
+        }
+        
+        if(l1) d->next = l1;
+        if(l2) d->next = l2;
+        
+        return dummy.next;
+    }
+};

Palindrome_Partitioning.cpp

@@ -0,0 +1,43 @@
+class Solution {
+public:
+    vector<vector<string>> partition(string s) {
+        if(s == "") return vector<vector<string>>();
+        
+        vector<vector<string>> result;
+        vector<string> t;
+        partition_helper(result, t, s);
+        
+        return result;
+    }
+    
+private:
+    void partition_helper(vector<vector<string>> &result, vector<string> &sofar, string rest){
+        if(rest.empty()){
+            result.push_back(sofar);
+            return;
+        }
+        
+        string w;
+        for(int i = 0; i < rest.size(); i++){
+            w = rest.substr(0, i+1);
+            if(is_pal(w)){
+                sofar.push_back(w);
+                partition_helper(result, sofar, rest.substr(i+1));
+                sofar.pop_back();
+            }
+        }
+    }
+    
+    bool is_pal(string &st){
+        int i = 0;
+        int j = st.size()-1;
+        
+        while(i < j){
+            if(st[i] != st[j]) return false;
+            i++;
+            j--;
+        }
+        return true;
+    }
+};
+

Permutations.cpp

@@ -13,7 +13,6 @@ class Solution {
 
 private:
     // sofar and rest can be passed by reference to avoid unnecessary
-    // space allocation
     void permute_helper(vector<vector<int>> &result, vector<int> &sofar, vector<int> &rest){
         if(rest.empty()){
             result.push_back(sofar);

Populating_Next_Right_Pointers_in_Each_Node.cpp

@@ -0,0 +1,22 @@
+/**
+ * Definition for binary tree with next pointer.
+ * struct TreeLinkNode {
+ *  int val;
+ *  TreeLinkNode *left, *right, *next;
+ *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void connect(TreeLinkNode *root) {
+        if(root == nullptr) return;
+        if(root->left == nullptr && root->right == nullptr) return;
+        
+        root->left->next = root->right;
+        if(root->next){
+            root->right->next = root->next->left;
+        }
+        connect(root->left);
+        connect(root->right);
+    }
+};

Populating_Next_Right_Pointers_in_Each_Node_2.cpp

@@ -0,0 +1,32 @@
+/**
+ * Definition for binary tree with next pointer.
+ * struct TreeLinkNode {
+ *  int val;
+ *  TreeLinkNode *left, *right, *next;
+ *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void connect(TreeLinkNode *root) {
+        if(root == nullptr) return;
+        if(root->left == nullptr && root->right == nullptr) return;
+        
+        queue<TreeLinkNode *> cq, nq;
+        cq.push(root);
+        
+        TreeLinkNode *t = nullptr;
+        while(!cq.empty()){
+            t = cq.front();
+            cq.pop();
+            
+            if(t->left) nq.push(t->left);
+            if(t->right) nq.push(t->right);
+            
+            if(!cq.empty()) t->next = cq.front();
+            else{
+                swap(cq, nq);
+            }
+        }
+    }
+};

Remove_Duplicates_from_Sorted_Array.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int removeDuplicates(int A[], int n) {
+        if(n <= 1) return n;
+        
+        int i = 0;
+        int j = 1;
+        
+        while(j < n){
+            if(A[i] == A[j]){
+                j++;
+            }else{
+                A[++i] = A[j++];
+            }
+        }
+        return i+1;
+    }
+};

Remove_Duplicates_from_Sorted_Array_2.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int removeDuplicates(int A[], int n) {
+        if(n <= 2) return n;
+        
+        int p = 0;
+        int q = p+1;
+        int cnt = 1;
+        
+        while(q < n){
+            if(A[p] == A[q]){
+                cnt++;
+                if(cnt == 2){
+                   A[++p] = A[q++]; 
+                }else q++;
+            }else{
+                A[++p] = A[q++];
+                cnt = 1;
+            }
+        }
+        
+        return p+1;
+    }
+};