added missed file

algorithms/cpp/matrixCellsInDistanceOrder/MatrixCellsInDistanceOrder.cpp

@@ -0,0 +1,74 @@
+// Source : https://leetcode.com/problems/matrix-cells-in-distance-order/
+// Author : Hao Chen
+// Date   : 2019-04-21
+
+/***************************************************************************************************** 
+ *
+ * We are given a matrix with R rows and C columns has cells with integer coordinates (r, c), where 0 
+ * <= r < R and 0 <= c < C.
+ * 
+ * Additionally, we are given a cell in that matrix with coordinates (r0, c0).
+ * 
+ * Return the coordinates of all cells in the matrix, sorted by their distance from (r0, c0) from 
+ * smallest distance to largest distance.  Here, the distance between two cells (r1, c1) and (r2, c2) 
+ * is the Manhattan distance, |r1 - r2| + |c1 - c2|.  (You may return the answer in any order that 
+ * satisfies this condition.)
+ * 
+ * Example 1:
+ * 
+ * Input: R = 1, C = 2, r0 = 0, c0 = 0
+ * Output: [[0,0],[0,1]]
+ * Explanation: The distances from (r0, c0) to other cells are: [0,1]
+ * 
+ * Example 2:
+ * 
+ * Input: R = 2, C = 2, r0 = 0, c0 = 1
+ * Output: [[0,1],[0,0],[1,1],[1,0]]
+ * Explanation: The distances from (r0, c0) to other cells are: [0,1,1,2]
+ * The answer [[0,1],[1,1],[0,0],[1,0]] would also be accepted as correct.
+ * 
+ * Example 3:
+ * 
+ * Input: R = 2, C = 3, r0 = 1, c0 = 2
+ * Output: [[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
+ * Explanation: The distances from (r0, c0) to other cells are: [0,1,1,2,2,3]
+ * There are other answers that would also be accepted as correct, such as 
+ * [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]].
+ * 
+ * Note:
+ * 
+ * 	1 <= R <= 100
+ * 	1 <= C <= 100
+ * 	0 <= r0 < R
+ * 	0 <= c0 < C
+ * 
+ ******************************************************************************************************/
+
+class Solution {
+public:
+    void put(int R, int C, int r, int c, vector<vector<int>>& res) {
+        if (r>=0 && r < R && c>=0 && c<C ) {
+            res.push_back({r,c});
+        }
+    }
+    vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {
+        int n =  R+C-2;
+        vector<vector<int>> result;
+        result.push_back({r0,c0});
+        for(int i=1; i<= n; i++) {
+            // from (r0-i, c0) to (r0, c0+i)
+            for(int r=r0-i,c=c0;r!=r0; r++, c++)  put (R, C, r ,c, result);
+
+            // from  (r0, c0+i) to (r0+i, c0)
+            for(int r=r0, c=c0+i; c!=c0; r++, c-- ) put (R, C, r, c, result);
+
+            // from (r0+i, c0) to (r0, c0-i)
+            for (int r=r0+i, c=c0; r!=r0; r--, c--) put (R, C, r, c, result);
+
+            // from (r0, c0-i) to (r0-i, c0)
+            for (int r=r0, c=c0-i; c!=c0; r--, c++) put (R, C, r, c, result);
+        }
+
+        return result;
+    }
+};

algorithms/cpp/uniqueEmailAddresses/UniqueEmailAddresses.cpp

@@ -0,0 +1,70 @@
+// Source : https://leetcode.com/problems/unique-email-addresses/
+// Author : Hao Chen
+// Date   : 2020-07-26
+
+/***************************************************************************************************** 
+ *
+ * Every email consists of a local name and a domain name, separated by the @ sign.
+ * 
+ * For example, in alice@leetcode.com, alice is the local name, and leetcode.com is the domain name.
+ * 
+ * Besides lowercase letters, these emails may contain '.'s or '+'s.
+ * 
+ * If you add periods ('.') between some characters in the local name part of an email address, mail 
+ * sent there will be forwarded to the same address without dots in the local name.  For example, 
+ * "alice.z@leetcode.com" and "alicez@leetcode.com" forward to the same email address.  (Note that 
+ * this rule does not apply for domain names.)
+ * 
+ * If you add a plus ('+') in the local name, everything after the first plus sign will be ignored. 
+ * This allows certain emails to be filtered, for example m.y+name@email.com will be forwarded to 
+ * my@email.com.  (Again, this rule does not apply for domain names.)
+ * 
+ * It is possible to use both of these rules at the same time.
+ * 
+ * Given a list of emails, we send one email to each address in the list.  How many different 
+ * addresses actually receive mails? 
+ * 
+ * Example 1:
+ * 
+ * Input: 
+ * ["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"
+ * ]
+ * Output: 2
+ * Explanation: "testemail@leetcode.com" and "testemail@lee.tcode.com" actually receive mails
+ * 
+ * Note:
+ * 
+ * 	1 <= emails[i].length <= 100
+ * 	1 <= emails.length <= 100
+ * 	Each emails[i] contains exactly one '@' character.
+ * 	All local and domain names are non-empty.
+ * 	Local names do not start with a '+' character.
+ * 
+ ******************************************************************************************************/
+
+class Solution {
+public:
+    int numUniqueEmails(vector<string>& emails) {
+        unordered_map<string, int> dict;
+        for (auto& email : emails) {
+            string addr;
+
+            for(int i=0; i<email.size(); i++) {
+                if (email[i] == '.' ) continue;
+
+                if (email[i] == '+') {
+                    while( email[++i] != '@');
+                }
+                if (email[i] =='@') {
+                    addr += email.substr(i);
+                    break;
+                }
+                addr += email[i];
+            }
+
+            dict[addr]++;
+        }
+        return dict.size();
+    }
+
+};

algorithms/cpp/validPerfectSquare/ValidPerfectSquare.cpp

@@ -0,0 +1,66 @@
+// Source : https://leetcode.com/problems/valid-perfect-square/description/
+// Author : Hao Chen
+// Date   : 2018-06-26
+
+/*************************************************************************************** 
+ *
+ * Given a positive integer num, write a function which returns True if num is a 
+ * perfect square else False.
+ * 
+ * 
+ * Note: Do not use any built-in library function such as sqrt.
+ * 
+ * 
+ * Example 1:
+ * 
+ * Input: 16
+ * Returns: True
+ * 
+ * 
+ * 
+ * Example 2:
+ * 
+ * Input: 14
+ * Returns: False
+ * 
+ * 
+ * 
+ * Credits:Special thanks to @elmirap for adding this problem and creating all test 
+ * cases.
+ ***************************************************************************************/
+class Solution {
+public:
+    // time limited error for  the MAX_INT.
+    bool isPerfectSquare1(int num) {
+        //binary searching...
+        int left = 0, right = num;
+        
+        while (left <= right) {
+            //cout << left << "," << right << endl;
+            int mid = left + (right - left)/2;
+            int n = mid * mid;
+            if ( n == num) return true;
+            if ( n < num ) left = mid + 1;
+            else right = mid - 1;
+        }
+        
+        return false; 
+        
+    }
+    
+    // the stupid way is best & fast.
+    bool isPerfectSquare2(int num) {
+        for (int i=1; i <= num/i ; i++ ) {
+            if ( i*i == num) return true;
+        }
+        
+        return false;
+    }
+    
+    
+    bool isPerfectSquare(int num) {
+        return isPerfectSquare2(num);
+        return isPerfectSquare1(num);
+    }
+    
+};