merge

.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

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

algorithms/cpp/3Sum/3Sum.cpp

@@ -30,7 +30,7 @@ using namespace std;
 
 
 /*
- *   Simlar like "Two Number" problem, we can have the simlar solution.
+ *   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,  
@@ -47,6 +47,7 @@ using namespace std;
 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());
@@ -71,7 +72,7 @@ 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(low<n-1 && num[low]==num[low+1]) low++; 
                 while(high>0 && num[high]==num[high-1]) high--; 
                 low++;
                 high--;
@@ -81,7 +82,7 @@ vector<vector<int> > threeSum(vector<int> &num) {
                 high--;
             } else{
                 //skip the duplication
-                while(low<n && num[low]==num[low+1]) low++;
+                while(low<n-1 && num[low]==num[low+1]) low++;
                 low++;
             } 
         }

algorithms/cpp/UTF8Validation/UTF8Validation.cpp

@@ -0,0 +1,86 @@
+// Source : https://leetcode.com/problems/utf-8-validation/
+// Author : Hao Chen
+// Date   : 2016-09-08
+
+/*************************************************************************************** 
+ *
+ * A character in UTF8 can be from 1 to 4 bytes long, subjected to the following rules:
+ * 
+ * For 1-byte character, the first bit is a 0, followed by its unicode code.
+ * For n-bytes character, the first n-bits are all one's, the n+1 bit is 0, followed by 
+ * n-1 bytes with most significant 2 bits being 10.
+ * 
+ * This is how the UTF-8 encoding would work:
+ * 
+ *    Char. number range  |        UTF-8 octet sequence
+ *    --------------------+---------------------------------------------
+ *    0000 0000-0000 007F | 0xxxxxxx
+ *    0000 0080-0000 07FF | 110xxxxx 10xxxxxx
+ *    0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
+ *    0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ * 
+ * Given an array of integers representing the data, return whether it is a valid utf-8 
+ * encoding.
+ * 
+ * Note:
+ * The input is an array of integers. Only the least significant 8 bits of each integer 
+ * is used to store the data. This means each integer represents only 1 byte of data.
+ * 
+ * Example 1:
+ * 
+ * data = [197, 130, 1], which represents the octet sequence: 11000101 10000010 
+ * 00000001.
+ * 
+ * Return true.
+ * It is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character.
+ * 
+ * Example 2:
+ * 
+ * data = [235, 140, 4], which represented the octet sequence: 11101011 10001100 
+ * 00000100.
+ * 
+ * Return false.
+ * The first 3 bits are all one's and the 4th bit is 0 means it is a 3-bytes character.
+ * The next byte is a continuation byte which starts with 10 and that's correct.
+ * But the second continuation byte does not start with 10, so it is invalid.
+ ***************************************************************************************/
+
+
+class Solution {
+public:
+    bool validUtf8(vector<int>& data) {
+        int i = 0;
+        while ( i < data.size() ) {
+            if ( (data[i] & 0x80) == 0 ){
+                i++;
+                continue;
+            }
+
+            int len = 0;
+            if ( (data[i] & 0xE0) == 0xC0 ) { // checking 110xxxxx
+                len = 2;
+            }else if ( (data[i] & 0xF0) == 0xE0) { // checking 1110xxxx
+                len = 3;
+            }else if ( (data[i] & 0xF8) == 0xF0) { // checking 11110xxx
+                len = 4;
+            }else {
+                return false;
+            }
+
+
+            for (int j=i+1; j < i+len; j++) { //checking 10xxxxxx
+                if ( (data[j] & 0xC0) != 0x80 ) {
+                    return false;
+                }
+            }
+
+            i += len ;
+
+            if (i > data.size()) {
+                return false;
+            }
+
+        }
+        return true;
+    }
+};

algorithms/cpp/accountsMerge/AccountsMerge.cpp

@@ -0,0 +1,174 @@
+// Source : https://leetcode.com/problems/accounts-merge/
+// Author : Hao Chen
+// Date   : 2019-03-29
+
+/***************************************************************************************************** 
+ *
+ * Given a list accounts, each element accounts[i] is a list of strings, where the first element 
+ * accounts[i][0] is a name, and the rest of the elements are emails representing emails of the 
+ * account.
+ * 
+ * Now, we would like to merge these accounts.  Two accounts definitely belong to the same person if 
+ * there is some email that is common to both accounts.  Note that even if two accounts have the same 
+ * name, they may belong to different people as people could have the same name.  A person can have 
+ * any number of accounts initially, but all of their accounts definitely have the same name.
+ * 
+ * After merging the accounts, return the accounts in the following format: the first element of each 
+ * account is the name, and the rest of the elements are emails in sorted order.  The accounts 
+ * themselves can be returned in any order.
+ * 
+ * Example 1:
+ * 
+ * Input: 
+ * accounts = [["John", "[email protected]", "[email protected]"], ["John", "[email protected]"], 
+ * ["John", "[email protected]", "[email protected]"], ["Mary", "[email protected]"]]
+ * Output: [["John", '[email protected]', '[email protected]', '[email protected]'],  ["John", 
+ * "[email protected]"], ["Mary", "[email protected]"]]
+ * 
+ * Explanation: 
+ * The first and third John's are the same person as they have the common email "[email protected]".
+ * The second John and Mary are different people as none of their email addresses are used by other 
+ * accounts.
+ *
+ * We could return these lists in any order, for example the answer [['Mary', '[email protected]'], 
+ * ['John', '[email protected]'], 
+ * ['John', '[email protected]', '[email protected]', '[email protected]']] would still be accepted.
+ * 
+ * Note:
+ * The length of accounts will be in the range [1, 1000].
+ * The length of accounts[i] will be in the range [1, 10].
+ * The length of accounts[i][j] will be in the range [1, 30].
+ ******************************************************************************************************/
+
+
+//Bad Performance Solution
+class Solution_Time_Limit_Exceeded {
+public:
+    // We can orginze all relevant emails to a chain,
+    // then we can use Union Find algorithm
+    // Besides, we also need to map the relationship between name and email.
+    vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
+        unordered_map<string, string> emails_chains; // email chains
+        unordered_map<string, string> names; // names to email chains' head
+
+        //initialization
+        for(int i = 0 ; i<accounts.size();i++) {
+            auto& account = accounts[i];
+            auto& name = account[0];
+            for (int j=1; j<account.size(); j++) {
+                auto& email = account[j];
+                if ( names.find(email) == names.end() ) {
+                    emails_chains[email] = email;
+                    names[email] = name;
+                }
+                join(emails_chains, account[1], email);
+            }
+        }
+
+        //reform the emails
+        unordered_map<string, set<string>> res;
+        for( auto& acc : accounts ) {
+            string e = find(emails_chains, acc[1]);
+            res[e].insert(acc.begin()+1, acc.end());
+        }
+
+        //output the result
+        vector<vector<string>> result;
+        for (auto pair : res) {
+            vector<string> emails(pair.second.begin(), pair.second.end());
+            emails.insert(emails.begin(), names[pair.first]);
+            result.push_back(emails);
+        }
+        return result;
+    }
+
+    string find(unordered_map<string, string>& emails_chains,
+                string email) {
+        while( email != emails_chains[email] ){
+            email = emails_chains[email];
+        }
+        return email;
+    }
+
+    bool join(unordered_map<string, string>& emails_chains,
+              string& email1, string& email2) {
+        string e1 = find(emails_chains, email1);
+        string e2 = find(emails_chains, email2);
+        if ( e1 != e2 )  emails_chains[e1] = email2;
+        return e1 == e2;
+    }
+};
+
+//
+// Performance Tunning
+// -----------------
+//
+// The above algorithm need to do string comparison, it causes lots of efforts
+// So, we allocated the ID for each email, and compare the ID would save the time.
+//
+// Furthermore, we can use the Group-Email-ID instead of email ID,
+// this would save more time.
+//
+class Solution {
+public:
+    // We can orginze all relevant emails to a chain,
+    // then we can use Union Find algorithm
+    // Besides, we also need to map the relationship between name and email.
+    vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
+        unordered_map<string, int> emails_id; //using email ID for union find
+        unordered_map<int, int> emails_chains; // email chains
+        unordered_map<int, string> names; // email id & name
+
+        //initialization & join
+        for(int i = 0 ; i<accounts.size();i++) {
+
+            // using the account index as the emails group ID,
+            // this could simplify the emails chain.
+            emails_chains[i] = i;
+
+            auto& account = accounts[i];
+            auto& name = account[0];
+            for (int j=1; j<account.size(); j++) {
+                auto& email = account[j];
+                if ( emails_id.find(email) == emails_id.end() ) {
+                    emails_id[email] = i;
+                    names[i] = name;
+                }else {
+                    join( emails_chains, i, emails_id[email] );
+                }
+
+            }
+        }
+
+        //reform the emails
+        unordered_map<int, set<string>> res;
+        for(int i=0; i<accounts.size(); i++) {
+            int idx = find(emails_chains, i);
+            res[idx].insert(accounts[i].begin()+1, accounts[i].end());
+        }
+
+
+        //output the result
+        vector<vector<string>> result;
+        for (auto pair : res) {
+            vector<string> emails( pair.second.begin(), pair.second.end() );
+            emails.insert(emails.begin(), names[pair.first]);
+            result.push_back(emails);
+        }
+        return result;
+    }
+
+    int find(unordered_map<int, int>& emails_chains, int id) {
+        while( id != emails_chains[id] ){
+            id = emails_chains[id];
+        }
+        return id;
+    }
+
+    bool join(unordered_map<int, int>& emails_chains, int id1, int id2) {
+        int e1 = find(emails_chains, id1);
+        int e2 = find(emails_chains, id2);
+        if ( e1 != e2 )  emails_chains[e1] = e2;
+        return e1 == e2;
+    }
+};

algorithms/cpp/addStrings/AddStrings.cpp

@@ -0,0 +1,48 @@
+// Source : https://leetcode.com/problems/add-strings/
+// Author : Hao Chen
+// Date   : 2016-11-12
+
+/*************************************************************************************** 
+ *
+ * Given two non-negative numbers num1 and num2 represented as string, return the sum 
+ * of num1 and num2.
+ * 
+ * Note:
+ * 
+ * The length of both num1 and num2 is 
+ * Both num1 and num2 contains only digits 0-9.
+ * Both num1 and num2 does not contain any leading zero.
+ * You must not use any built-in BigInteger library or convert the inputs to integer 
+ * directly.
+ ***************************************************************************************/
+
+class Solution {
+public:
+    string addStrings(string num1, string num2) {
+        string& longstr  = ( num1.size() >= num2.size() ? num1 : num2 );
+        string& shortstr = ( num1.size() <  num2.size() ? num1 : num2 );
+
+        int longlen = longstr.size();
+        int shortlen = shortstr.size();
+
+        char carry = 0;
+        int i, j;
+
+        string result;
+        for (i = longlen-1, j=shortlen-1; i>=0; i--, j--) {
+            int add = 0;
+            if (j>=0) {
+                add = longstr[i] + shortstr[j] - 2 * '0' + carry;
+            }else{
+                add = longstr[i] - '0' + carry;
+            }
+            carry = add/10;
+            result = char('0' + add % 10) + result;
+        }
+
+        if (carry) {
+            result = '1' + result;
+        }
+        return result;
+    }
+};