Merge pull request #1 from haoel/master

Sync code

Author: pjq

.gitconfig

@@ -0,0 +1,5 @@
+[alias]
+    lg0 = log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --
+    lg1 = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)' --all
+    lg2 = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold cyan)%aD%C(reset) %C(bold green)(%ar)%C(reset)%C(bold yellow)%d%C(reset)%n''          %C(white)%s%C(reset) %C(dim white)- %an%C(reset)' --all
+    lg = !"git lg0"

.gitignore

@@ -0,0 +1,3 @@
+.idea
+algorithms-java/out
+*.class

README.md

@@ -26,28 +26,45 @@
 #include <vector>
 #include <set>
 #include <algorithm>
+
 using namespace std;
 
 
-//solution:  http://en.wikipedia.org/wiki/3SUM
+/*
+ *   Similar like "Two Number" problem, we can have the simlar solution.
+ *
+ *   Suppose the input array is S[0..n-1], 3SUM can be solved in O(n^2) time on average by 
+ *   inserting each number S[i] into a hash table, and then for each index i and j,  
+ *   checking whether the hash table contains the integer - (s[i]+s[j])
+ *
+ *   Alternatively, the algorithm below first sorts the input array and then tests all 
+ *   possible pairs in a careful order that avoids the need to binary search for the pairs 
+ *   in the sorted list, achieving worst-case O(n^n)
+ *
+ *   Solution:  Quadratic algorithm
+ *   http://en.wikipedia.org/wiki/3SUM
+ *
+ */
 vector<vector<int> > threeSum(vector<int> &num) {
 
     vector< vector<int> > result;
+    if(num.size() == 0 || num.size() == 1 || num.size() == 2) return result;
 
+    //sort the array, this is the key
     sort(num.begin(), num.end());
 
     int n = num.size();
 
     for (int i=0; i<n-2; i++) {
         //skip the duplication
-        if (i>0 && num[i-1]==num[i]) continue;
+        if (i > 0 && num[i - 1] == num[i]) continue;
         int a = num[i];
-        int low = i+1;
-        int high = n-1;
-        while ( low < high ) {
+        int low = i + 1;
+        int high = n - 1;
+        while (low < high) {
             int b = num[low];
             int c = num[high];
-            if (a+b+c == 0) {
+            if (a + b + c == 0) {
                 //got the soultion
                 vector<int> v;
                 v.push_back(a);
@@ -56,17 +73,17 @@ vector<vector<int> > threeSum(vector<int> &num) {
                 result.push_back(v);
                 // Continue search for all triplet combinations summing to zero.
                 //skip the duplication
-                while(low<n && num[low]==num[low+1]) low++; 
-                while(high>0 && num[high]==num[high-1]) high--; 
+                while(low < n - 1 && num[low] == num[low + 1]) low++; 
+                while(high > 0 && num[high] == num[high - 1]) high--; 
                 low++;
                 high--;
             } else if (a+b+c > 0) {
                 //skip the duplication
-                while(high>0 && num[high]==num[high-1]) high--;
+                while(high > 0 && num[high] == num[high - 1]) high--;
                 high--;
-            } else{
+            } else {
                 //skip the duplication
-                while(low<n && num[low]==num[low+1]) low++;
+                while(low < n - 1 && num[low] == num[low + 1]) low++;
                 low++;
             } 
         }
@@ -82,21 +99,21 @@ int sum(vector<int>& v);
 vector<vector<int> > threeSum2(vector<int> &num) {
     vector< vector<int> > result;
     vector< vector<int> > r = combination(num, 3);
-    for (int i=0; i<r.size(); i++){
-        if (isSumZero(r[i])){
+    for (int i = 0; i < r.size(); i++) {
+        if (isSumZero(r[i])) {
             result.push_back(r[i]);
         }
     }
     return result;
 }
 
-bool isSumZero(vector<int>& v){
-    return sum(v)==0;
+bool isSumZero(vector < int>& v) {
+    return sum(v) == 0;
 }
 
-int sum(vector<int>& v){
-    int s=0;
-    for(int i=0; i<v.size(); i++){
+int sum(vector<int>& v) {
+    int s = 0;
+    for(int i = 0; i < v.size(); i++) {
         s += v[i];
     }
     return s;
@@ -107,39 +124,39 @@ vector<vector<int> > combination(vector<int> &v, int k) {
     vector<vector<int> > result;
     vector<int> d;
     int n = v.size();
-    for (int i=0; i<n; i++){
-        d.push_back( (i<k) ? 1 : 0 );
+    for (int i = 0; i < n; i++) {
+        d.push_back( (i < k) ? 1 : 0 );
     }
 
     //1) from the left, find the [1,0] pattern, change it to [0,1]
     //2) move all of the 1 before the pattern to the most left side
     //3) check all of 1 move to the right
-    while(1){
+    while(1) {
         vector<int> tmp;
-        for(int x=0; x<n; x++){
+        for(int x = 0; x < n; x++) {
             if (d[x]) tmp.push_back(v[x]);
         }
         sort(tmp.begin(), tmp.end());
         result.push_back(tmp);
         //step 1), find [1,0] pattern
         int i;
         bool found = false;
-        int ones =0;
-        for(i=0; i<n-1; i++){
+        int ones = 0;
+        for(i = 0; i < n - 1; i++) {
 
-            if (d[i]==1 && d[i+1]==0){
-                d[i]=0; d[i+1]=1;
+            if (d[i] == 1 && d[i + 1] == 0) {
+                d[i] = 0; d[i + 1] = 1;
                 found = true;
                 //step 2) move all of right 1 to the most left side
-                for (int j=0; j<i; j++){
-                    d[j]=( ones > 0 ) ? 1 : 0;
+                for (int j = 0; j < i; j++) {
+                    d[j] = ( ones > 0 ) ? 1 : 0;
                     ones--;
                 }
                 break;
             }
-            if (d[i]==1) ones++;
+            if (d[i] == 1) ones++;
         }
-        if (!found){
+        if (!found) {
             break;
         }
 
@@ -150,9 +167,9 @@ vector<vector<int> > combination(vector<int> &v, int k) {
 
 void printMatrix(vector<vector<int> > &matrix)
 {
-    for(int i=0; i<matrix.size(); i++){
+    for(int i = 0; i < matrix.size(); i++) {
         printf("{");
-        for(int j=0; j< matrix[i].size(); j++) {
+        for(int j = 0; j < matrix[i].size(); j++) {
             printf("%3d ", matrix[i][j]) ;
         }
         printf("}\n");
@@ -163,9 +180,9 @@ void printMatrix(vector<vector<int> > &matrix)
 
 int main()
 {
-    //int a[] = {-1, 0, 1, 2, -1, 1, -4};
-    int a[] = {-1, 1, 1, 1, -1, -1, 0,0,0};
-    vector<int> n(a, a+sizeof(a)/sizeof(int));
+    //int a[] = { -1, 0, 1, 2, -1, 1, -4 };
+    int a[] = { -1, 1, 1, 1, -1, -1, 0,0,0 };
+    vector<int> n(a, a + sizeof(a)/sizeof(int));
     vector< vector<int> > result = threeSum(n);
     printMatrix(result);    
     return 0;

src/3Sum/3Sum.cpp renamed to algorithms/cpp/3Sum/3Sum.cpp

@@ -0,0 +1,104 @@
+// Source : https://oj.leetcode.com/problems/3sum-closest/
+// Author : Hao Chen
+// Date   : 2014-07-03
+
+/********************************************************************************** 
+* 
+* Given an array S of n integers, find three integers in S such that the sum is 
+* closest to a given number, target. Return the sum of the three integers. 
+* You may assume that each input would have exactly one solution.
+* 
+*     For example, given array S = {-1 2 1 -4}, and target = 1.
+* 
+*     The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+* 
+*               
+**********************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <vector>
+#include <set>
+#include <algorithm>
+
+using namespace std;
+
+#define INT_MAX 2147483647
+//solution:  http://en.wikipedia.org/wiki/3SUM
+//the idea as blow:
+//  1) sort the array.
+//  2) take the element one by one, calculate the two numbers in reset array.
+//
+//notes: be careful the duplication number.
+//
+// for example:
+//    [-4,-1,-1,1,2]    target=1
+// 
+//    take -4, can cacluate the "two number problem" of the reset array [-1,-1,1,2] while target=5
+//    [(-4),-1,-1,1,2]  target=5  distance=4
+//           ^      ^ 
+//    because the -1+2 = 1 which < 5, then move the `low` pointer(skip the duplication)
+//    [(-4),-1,-1,1,2]  target=5  distance=2
+//                ^ ^ 
+//    take -1(skip the duplication), can cacluate the "two number problem" of the reset array [1,2] while target=2
+//    [-4,-1,(-1),1,2]  target=2  distance=1
+//                ^ ^ 
+int threeSumClosest(vector<int> &num, int target) {
+    //sort the array
+    sort(num.begin(), num.end());
+
+    int n = num.size();
+    int distance = INT_MAX;
+    int result;
+
+    for (int i=0; i<n-2; i++) {
+        //skip the duplication
+        if (i > 0 && num[i - 1] == num[i]) continue;
+        int a = num[i];
+        int low = i + 1;
+        int high = n - 1;
+        //convert the 3sum to 2sum problem
+        while (low < high) {
+            int b = num[low];
+            int c = num[high];
+            int sum = a + b + c;
+            if (sum - target == 0) {
+                //got the final soultion
+                return target;
+            } else {
+                //tracking the minmal distance
+                if (abs(sum - target) < distance ) {
+                    distance = abs(sum - target);
+                    result = sum;
+                }
+
+                if (sum - target > 0) {
+                    //skip the duplication
+                    while(high > 0 && num[high] == num[high - 1]) high--;
+                    //move the `high` pointer
+                    high--;
+                } else {
+                    //skip the duplication
+                    while(low < n && num[low] == num[low + 1]) low++;
+                    //move the `low` pointer
+                    low++;
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+
+
+
+int main()
+{
+    int a[] = { -1, 2, 1, -4 };
+    vector<int> n(a, a + sizeof(a)/sizeof(int));
+    int target = 1;
+    cout << threeSumClosest(n, target) << endl;
+    return 0;
+}