4th homework

1st/homework_1/id_45/2_add_two_numbers.cpp

@@ -0,0 +1,62 @@
+#include <stdio.h>
+using namespace std;
+
+/*Definition for singly-linked list.*/
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution {
+public:
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+        if ((l1 == NULL) && (l2 == NULL))
+            return NULL;
+        if (l1 == NULL)
+            return l2;
+        if (l2 == NULL)
+            return l1;
+
+        int sum, carry = 0;
+        ListNode *pre_l1, *result;
+        result = l1;
+        while ((l1 != NULL) && (l2 != NULL)) {
+            sum = l1->val + l2->val + carry;
+            carry = sum / 10; 
+            l1->val = sum % 10;
+            pre_l1 = l1; 
+            l1 = l1->next;
+            l2 = l2->next;
+        }
+
+        if (l1 == NULL) {
+            l1 = pre_l1;
+            l1->next = l2; 
+            l1 = l2;
+        }
+
+        while (l1 != NULL) {
+            sum = l1->val + carry;
+            carry = sum / 10;
+            l1->val = sum % 10;
+            pre_l1 = l1;
+            l1 = l1->next;
+        }
+
+        if (carry > 0) {
+            struct ListNode *last_node = new struct ListNode(carry);
+            pre_l1->next = last_node;
+        }
+        return result;
+    }
+};
+
+int main()
+{
+    struct ListNode *test = new ListNode(0);
+    test->val = 1;
+    test->next = NULL;
+
+    return 0;
+}

1st/homework_10/id_45/120_triangle.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int minimumTotal(vector<vector<int>>& triangle) {
+        int n = triangle.size();
+
+        if (n == 0)
+            return 0;
+
+        if (n == 1)
+            return triangle[0][0];
+
+        vector<int> cur_min_sum = triangle[n - 1]; 
+        for (int i = n - 2; i >= 0; --i) {
+            for (int j = 0; j < triangle[i].size(); ++j) {
+                cur_min_sum[j] = triangle[i][j] + min(cur_min_sum[j], cur_min_sum[j+1]);
+            }
+        }   
+        return cur_min_sum[0];
+    }
+};

1st/homework_2/id_45/15_3sum.cpp

@@ -0,0 +1,103 @@
+//Solution 1: TLE
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        int a, c;
+        map<int,int> record;
+        map<int,int>::iterator map_it;
+        vector<vector<int> > result;
+        set<multiset<int> > result_set;
+        set<multiset<int> >::iterator set_it;
+
+        if (nums.size() < 3)
+            return result;
+
+        for (int i = 0; i < nums.size() - 2; ++i) {
+            c = nums[i];
+            record.clear();
+            for (int j = i + 1; j < nums.size(); ++j) {
+                a = -c - nums[j];
+                map_it = record.find(a);
+                if (map_it != record.end()) {
+                    if (map_it->second == 0) {
+                        multiset<int> set_element;
+                        set_element.insert(a);
+                        set_element.insert(c);
+                        set_element.insert(nums[j]);
+                        result_set.insert(set_element);
+
+                        record[a] = 1;
+                        record[nums[j]] = 1;
+                    }
+                } else {
+                    record[nums[j]] = 0;
+                }
+            }
+        }
+
+        for (set_it = result_set.begin(); set_it != result_set.end(); ++set_it) {
+            vector<int> vec((*set_it).begin(), (*set_it).end());
+            result.push_back(vec);
+        }
+
+        return result;
+    }
+};
+
+//Solution 2
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        int l, r, c;
+        vector<vector<int> >result;
+        sort(nums.begin(), nums.end());
+
+        for (int i = 0; i < nums.size();) {
+            c = nums[i];
+            l = i + 1;
+            r = nums.size() - 1;
+            while (l < r) {
+                if (nums[l] + nums[r] > -c) {
+                    --r;
+                } else if(nums[l] + nums[r] < -c) {
+                    ++l;
+                } else {
+                    vector<int> vec;
+                    vec.push_back(c);
+                    vec.push_back(nums[l]);
+                    vec.push_back(nums[r]);
+                    result.push_back(vec);
+
+                    int l_val = nums[l];
+                    ++l;
+                    while (l < r) {
+                        if (l_val == nums[l]) {
+                            ++l;
+                        } else {
+                            break;
+                        }
+                    }
+
+                    int r_val = nums[r];
+                    --r;
+                    while (l < r) {
+                        if (r_val == nums[r]) {
+                            --r;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }       
+            ++i;
+            while (i < nums.size()) {
+                if (c == nums[i]) {
+                    ++i;
+                } else {
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+};

1st/homework_3/id_45/18_4sum.cpp

@@ -0,0 +1,85 @@
+#include <stdio.h>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+class Solution {
+public:
+    vector<vector<int>> fourSum(vector<int>& nums, int target) {
+        int l, r, c, d, two_sum;
+        vector<vector<int> >result;
+        sort(nums.begin(), nums.end());
+
+        for (int k = 0; k < nums.size();) {
+            d = nums[k];
+            for (int i = k + 1; i < nums.size();) {
+                c = nums[i];
+                l = i + 1;
+                r = nums.size() - 1;
+
+                while (l < r) {
+                    two_sum = nums[l] + nums[r];
+                    if (two_sum > target - c - d) {
+                        --r;
+                    } else if(two_sum < target - c - d) {
+                        ++l;
+                    } else {
+                        vector<int> vec;
+                        vec.push_back(d);
+                        vec.push_back(c);
+                        vec.push_back(nums[l]);
+                        vec.push_back(nums[r]);
+                        result.push_back(vec);
+
+                        int l_val = nums[l];
+                        ++l;
+                        while (l < r) {
+                            if (l_val == nums[l]) {
+                                ++l;
+                            } else {
+                                break;
+                            }
+                        }
+
+                        int r_val = nums[r];
+                        --r;
+                        while (l < r) {
+                            if (r_val == nums[r]) {
+                                --r;
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+                }
+                ++i;
+                while (i < nums.size()) {
+                    if (c == nums[i]) {
+                        ++i;
+                    } else {
+                        break;
+                    }
+                }
+            }
+            ++k;
+            while (k < nums.size()) {
+                if (d == nums[k]) {
+                    ++k;
+                } else {
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+};
+
+int main()
+{
+    Solution test_solution = Solution();
+    int target = 0;
+    int t_array[] = {1, 0, -1, 0, -2, 2};
+    vector<int> t_vec(t_array, t_array + sizeof(t_array) / sizeof(int));
+    test_solution.fourSum(t_vec, target);
+    return 0;
+}

1st/homework_4/id_45/75_sort_colors.cpp

@@ -0,0 +1,47 @@
+//Solution 1: one pass
+class Solution {
+public:
+    void sortColors(vector<int>& nums) {
+        int l = 0;
+        int r = nums.size() - 1;
+        for (int i = 0; i <= r; ++i) {
+            if (i == r) {
+                if (nums[i] != 0) {
+                    break;
+                }
+            }
+            if (nums[i] == 0) {
+                if (l < i) {
+                    int t = nums[i];
+                    nums[i] = nums[l];
+                    nums[l] = t;
+                }
+                ++l;
+
+            } else if (nums[i] == 2) {
+                int t = nums[i];
+                nums[i] = nums[r];
+                nums[r] = t;
+                --r;
+                --i;
+            }
+        }
+    }
+};
+
+//Solution 2: two pass
+class Solution {
+public:
+    void sortColors(vector<int>& nums) {
+        int color_cnt[3] = {0, 0, 0};
+        for (int i = 0; i < nums.size(); ++i) {
+            ++color_cnt[nums[i] % 3];
+        }
+        int k = 0;
+        for (int i = 0; i < 3; ++i) {
+            while (color_cnt[i]--) {
+                nums[k++] = i;
+            }
+        }
+    }
+};

1st/homework_5/id_45/53_maximum_subarray.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int sum = nums[0];
+        int result = sum;
+        for (int i = 1; i < nums.size(); ++i) {
+            sum += nums[i];
+            sum = sum < nums[i]? nums[i] : sum;
+            result = result < sum? sum : result;
+        }   
+        return result;
+    }
+};

1st/homework_6/id_45/80_remove_duplicates_from_sorted_array_II.cpp

@@ -0,0 +1,37 @@
+//Solution 1
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int len = nums.size();
+        if (len == 0)
+            return 0;
+
+        map<int, int> res_map;
+        for (int i = 0; i < len; ++i) {
+            ++res_map[nums[i]]; 
+        }
+
+        nums.clear();
+        map<int, int>::iterator it;
+        for (it = res_map.begin(); it != res_map.end(); ++it) {
+            if (it->second > 1) {
+                nums.push_back(it->first);
+            }
+            nums.push_back(it->first);
+        }
+        return nums.size();
+    }
+};
+
+//Solution 2
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int k = 0;
+        for (int i = 0; i < nums.size(); ++i) {
+            if (k < 2 || nums[i] > nums[k - 2]) 
+                nums[k++] = nums[i];
+        }
+        return k;
+    }
+};