Update solutions.

Author: AnnieKim

4Sum.h

@@ -1,6 +1,7 @@
 /*
  Author:     Annie Kim, [email protected]
  Date:       Apr 20, 2013
+ Update:     Sep 26, 2013
  Problem:    4Sum
  Difficulty: Medium
  Source:     http://leetcode.com/onlinejudge#question_18
@@ -19,109 +20,43 @@
  (-2, -1, 1, 2)
  (-2,  0, 0, 2)
 
- Solution: FourSum = TwoSum + TwoSum.
+ Solution: Similar to 3Sum, 2Sum.
  */
 
-struct TwoSum
-{
-    int sum;
-    int first;
-    int second;
-    TwoSum(int _first, int _second) {
-        first = _first;
-        second = _second;
-        sum = _first + _second;
-    }
-};
-bool increasing(TwoSum i, TwoSum j) { return (i.sum < j.sum); }
-
 class Solution {
-private:
-    vector<vector<int>> res;
-    map<int, int>       count;
-    vector<int>         uni;
-    vector<TwoSum>      sum;
-
 public:
     vector<vector<int> > fourSum(vector<int> &num, int target) {
-        res.clear();
-        if (num.size() < 4) return res;
-        UniqueAndCount(num);
-        buildTwoSum();
-        searchResult(target);
-        return res;
-    }
-
-private:
-    void UniqueAndCount(const vector<int> &num)
-    {
-        count.clear();
-        uni.clear();
-        for (int i = 0; i < num.size(); ++i) {
-            if (count[num[i]] == 0)
-                uni.push_back(num[i]);
-            count[num[i]]++;
-        }
-    }
-
-    void buildTwoSum()
-    {
-        sum.clear();
-        for (int i = 0; i < uni.size(); ++i)
-            for (int j = i + 1; j < uni.size(); ++j)
-                sum.push_back(TwoSum(uni[i], uni[j]));
-        // for duplicate numbers
-        for (map<int,int>::iterator it = count.begin(); it != count.end(); ++it)
-            if ((*it).second > 1)
-                sum.push_back(TwoSum((*it).first, (*it).first));
-        sort(sum.begin(), sum.end(), increasing);
-    }
-
-    void searchResult(int target)
-    {
-        int i = 0; int j = sum.size() - 1;
-        while (i < j)
+        int N = num.size();
+        vector<vector<int> > res;
+        if (N < 4) return res;
+        sort(num.begin(), num.end());
+        for (int i = 0; i < N; ++i)
         {
-            int s = sum[i].sum + sum[j].sum;
-            if (s == target) {
-                int m = i, n = j;
-                while (m < j && sum[m].sum == sum[i].sum) {
-                    n = j;
-                    while (m < n && sum[n].sum == sum[j].sum)
-                        pushResult(sum[m], sum[n--]);
-                    m++;
+            if (i > 0 && num[i] == num[i-1]) continue; // avoid duplicates
+            for (int j = i+1; j < N; ++j)
+            {
+                if (j > i+1 && num[j] == num[j-1]) continue; // avoid duplicates
+                int twosum = target - num[i] - num[j];
+                int l = j + 1, r = N - 1;
+                while (l < r)
+                {
+                    int sum = num[l] + num[r];
+                    if (sum == twosum) {
+                        vector<int> quadruplet(4);
+                        quadruplet[0] = num[i];
+                        quadruplet[1] = num[j];
+                        quadruplet[2] = num[l];
+                        quadruplet[3] = num[r];
+                        res.push_back(quadruplet);
+                        while (l < r && num[l+1] == num[l]) l++; // avoid duplicates
+                        while (l < r && num[r-1] == num[r]) r--; // avoid duplicates
+                        l++; r--;
+                    }
+                    else if (sum < twosum) l++;
+                    else r--;
                 }
-                i = m;
-                j = n;
-            } else if (s < target) {
-                i++;
-            } else {
-                j--;
             }
         }
-        // for the numbers that have more than 4 copies
-        for (map<int,int>::iterator it = count.begin(); it != count.end(); ++it)
-            if ((*it).second >= 4 && (*it).first * 4 == target)
-                pushResult(TwoSum((*it).first, (*it).first), TwoSum((*it).first, (*it).first));
-    }
-
-    void pushResult(const TwoSum &a, const TwoSum &b)
-    {
-        vector<int> quadruplet;
-        quadruplet.push_back(a.first);
-        quadruplet.push_back(a.second);
-        quadruplet.push_back(b.first);
-        quadruplet.push_back(b.second);
-        // check counts
-        map<int, int> used;
-        for (int i = 0; i < quadruplet.size(); ++i)
-            used[quadruplet[i]]++;
-        for (map<int, int>::iterator it = used.begin(); it != used.end(); ++it)
-            if ((*it).second > count[(*it).first])
-                return;
-        // avoid duplicates
-        sort(quadruplet.begin(), quadruplet.end());
-        if (find(res.begin(), res.end(), quadruplet) == res.end())
-            res.push_back(quadruplet);
+        return res;
     }
-};
+};

ReverseInteger.h

@@ -26,7 +26,7 @@ class Solution {
             res = res * 10 + (x % 10);
             x /= 10;
         }
-        assert(res > INT_MIN && res < INT_MAX);
+        assert(res >= INT_MIN && res <= INT_MAX);
         return res;
     }
-};
+};

ValidateBinarySearchTree.h

@@ -13,7 +13,7 @@
  Both the left and right subtrees must also be binary search trees.
 
  Solution: Recursion. 1. Add lower & upper bound. O(n)
-                      2. Inorder traversal with one addition parameter (value of predecessor). O(n)
+                      2. Inorder traversal with one additional parameter (value of predecessor). O(n)
  */
 
 /**

ZigZagConversion.h

@@ -1,6 +1,7 @@
 /*
  Author:     Annie Kim, [email protected]
  Date:       Apr 7, 2013
+ Update:     Sep 26, 2013
  Problem:    ZigZag Conversion
  Difficulty: Easy
  Source:     http://leetcode.com/onlinejudge#question_6
@@ -16,33 +17,29 @@
  string convert(string text, int nRows);
  convert("PAYPALISHIRING", 3) should return "PAHNAPLSIIGYIR".
 
- Solution: It's done if you find the rule!
+ Solution: ...
  */
 
 class Solution {
 public:
     string convert(string s, int nRows) {
-        if (nRows == 1) return s; 
+        if (nRows == 1) return s;
         string res;
-        int offset = 2 * (nRows - 1);
-        for (int i = 0; i < nRows; i++)
+        int inc = (nRows - 1) * 2, N = s.size();
+        for (int i = 0; i < nRows; ++i)
         {
-            if (i == 0 || i == nRows-1) {
-                for (int j = i; j < s.size(); j += offset)
-                    res.push_back(s[j]);
-            } else {
-                int j_1 = i;
-                int j_2 = j_1 + offset - i * 2;
-                bool use_1 = true;
-                while (use_1 ? j_1 < s.size() : j_2 < s.size())
-                {
-                    res.push_back(use_1 ? s[j_1] : s[j_2]);
-                    j_1 = use_1? j_1 + offset : j_1;
-                    j_2 = use_1? j_2 : j_2 + offset;
-                    use_1 = !use_1;
-                }
+            int j = 0;
+            while (true)
+            {
+                if (i > 0 && i < nRows-1 && j-i >= 0 && j-i < N)
+                    res.push_back(s[j-i]);
+                if (j+i < N)
+                    res.push_back(s[j+i]);
+                if (j+i >= N)
+                    break;
+                j += inc;
             }
-        } 
+        }
         return res;
     }
 };