pichina
diff --git a/‎README.md
Lines changed: 4 additions & 1 deletion b/‎README.md
Lines changed: 4 additions & 1 deletion
diff --git a/‎algorithms/anagrams/GroupAnagrams.cpp
Lines changed: 93 additions & 0 deletions b/‎algorithms/anagrams/GroupAnagrams.cpp
Lines changed: 93 additions & 0 deletions
diff --git a/‎algorithms/anagrams/ValidAnagram.cpp
Lines changed: 60 additions & 0 deletions b/‎algorithms/anagrams/ValidAnagram.cpp
Lines changed: 60 additions & 0 deletions
diff --git a/‎algorithms/anagrams/anagrams.cpp
Lines changed: 0 additions & 34 deletions b/‎algorithms/anagrams/anagrams.cpp
Lines changed: 0 additions & 34 deletions
diff --git a/‎algorithms/differentWaysToAddParentheses/DifferentWaysToAddParentheses.cpp
Lines changed: 108 additions & 0 deletions b/‎algorithms/differentWaysToAddParentheses/DifferentWaysToAddParentheses.cpp
Lines changed: 108 additions & 0 deletions
diff --git a/‎algorithms/happyNumber/HappyNumber.cpp
Lines changed: 4 additions & 4 deletions b/‎algorithms/happyNumber/HappyNumber.cpp
Lines changed: 4 additions & 4 deletions
@@ -8,6 +8,9 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|226|[Valid Anagrams](https://oj.leetcode.com/problems/valid-anagrams/)| [C++](./algorithms/anagrams/ValidAnagrams.cpp)|Easy|
+|225|[Different Ways to Add Parentheses](https://leetcode.com/problems/different-ways-to-add-parentheses/)|[C++](./algorithms/differentWaysToAddParentheses/DifferentWaysToAddParentheses.cpp)|Medium|
+|224|[Search a 2D Matrix II](https://leetcode.com/problems/search-a-2d-matrix-ii/)|[C++](./algorithms/search2DMatrix/search2DMatrix.II.cpp)|Medium|
 |223|[Sliding Window Maximum](https://leetcode.com/problems/sliding-window-maximum/)| [C++](./algorithms/slidingWindowMaximum/SlidingWindowMaximum.cpp)|Hard|
 |222|[Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/)| [C++](./algorithms/productOfArrayExceptSelf/ProductOfArrayExceptSelf.cpp)|Medium|
 |221|[Delete Node in a Linked List](https://leetcode.com/problems/delete-node-in-a-linked-list/)| [C++](./algorithms/deleteNodeInALinkedList/DeleteNodeInALinkedList.cpp)|Easy|
@@ -183,7 +186,7 @@ LeetCode
 |51|[N-Queens II](https://oj.leetcode.com/problems/n-queens-ii/)| [C++](./algorithms/nQueens/nQueuens.II.cpp)|Hard|
 |50|[N-Queens](https://oj.leetcode.com/problems/n-queens/)| [C++](./algorithms/nQueens/nQueuens.cpp)|Hard|
 |49|["Pow(x, n)"](https://oj.leetcode.com/problems/powx-n/)| [C++](./algorithms/pow/pow.cpp)|Medium|
-|48|[Anagrams](https://oj.leetcode.com/problems/anagrams/)| [C++](./algorithms/anagrams/anagrams.cpp)|Medium|
+|48|[Group Anagrams](https://oj.leetcode.com/problems/anagrams/)| [C++](./algorithms/anagrams/GroupAnagrams.cpp)|Medium|
 |47|[Rotate Image](https://oj.leetcode.com/problems/rotate-image/)| [C++](./algorithms/rotateImage/rotateImage.cpp)|Medium|
 |46|[Permutations II](https://oj.leetcode.com/problems/permutations-ii/)| [C++](./algorithms/permutations/permutations.II.cpp)|Hard|
 |45|[Permutations](https://oj.leetcode.com/problems/permutations/)| [C++](./algorithms/permutations/permutations.cpp)|Medium|
 
@@ -0,0 +1,93 @@
+// Source : https://oj.leetcode.com/problems/anagrams/
+// Author : Hao Chen
+// Date   : 2014-07-18
+
+/********************************************************************************** 
+ * 
+ * Given an array of strings, group anagrams together.
+ * 
+ * For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"], 
+ * Return:
+ * 
+ * [
+ *   ["ate", "eat","tea"],
+ *   ["nat","tan"],
+ *   ["bat"]
+ * ]
+ * 
+ * Note:
+ * 
+ * For the return value, each inner list's elements must follow the lexicographic order.
+ * All inputs will be in lower-case.
+ * 
+ * Update (2015-08-09):
+ * The signature of the function had been updated to return list<list<string>> instead 
+ * of list<string>, as suggested here. If you still see your function signature return 
+ * a list<string>, please click the reload button  to reset your code definition.
+ * 
+ **********************************************************************************/
+
+class Solution {
+public:
+    vector< vector<string> > groupAnagrams(vector<string> &strs) {
+        vector< vector<string> > result;
+        map<string, int> m;
+        for(int i=0; i<strs.size(); i++){
+            string word = strs[i];
+            sort(word.begin(), word.end());
+            if (m.find(word)==m.end()){
+                vector<string> v;
+                v.push_back(strs[i]);
+                result.push_back(v);
+                m[word] = result.size()-1;
+                
+            }else{
+                result[m[word]].push_back(strs[i]);
+            }
+        }
+        
+        for(int i=0; i<result.size(); i++){
+            sort(result[i].begin(), result[i].end());
+        }
+        return result;
+    }
+     
+    //using multiset 
+    vector< vector<string> > groupAnagrams01(vector<string> &strs) {
+        vector< vector<string> > result;
+        map<string, multiset<string>> m;
+        for(int i=0; i<strs.size(); i++){
+            string word = strs[i];
+            sort(word.begin(), word.end());
+            m[word].insert(strs[i]);
+        }
+        
+        for(auto item : m){
+            vector<string> v(item.second.begin(), item.second.end());
+            result.push_back(v);
+        }
+        return result;
+    }
+
+
+    //NOTICE: the below solution has been depracated as the problem has been updated!
+    vector<string> anagrams(vector<string> &strs) {
+        vector<string> result;
+        map<string, int> m;
+        for(int i=0; i<strs.size(); i++){
+            string word = strs[i];
+            //sort it can easy to check they are anagrams or not
+            sort(word.begin(), word.end());  
+            if (m.find(word)==m.end()){
+                m[word] = i;
+            }else{
+                if (m[word]>=0){
+                    result.push_back(strs[m[word]]);
+                    m[word]=-1;
+                }
+                result.push_back(strs[i]);
+            }
+        }
+        return result;
+    }
+};
@@ -0,0 +1,60 @@
+// Source : https://leetcode.com/problems/valid-anagram/
+// Author : Hao Chen
+// Date   : 2015-08-16
+
+/********************************************************************************** 
+ * 
+ * Given two strings s and t, write a function to determine if t is an anagram of s. 
+ * 
+ * For example,
+ * s = "anagram", t = "nagaram", return true.
+ * s = "rat", t = "car", return false.
+ * 
+ * Note:
+ * You may assume the string contains only lowercase alphabets.
+ *               
+ **********************************************************************************/
+
+
+class Solution {
+public:
+
+    //stupid way - but easy to understand  - 76ms
+    bool isAnagram01(string s, string t) {
+        sort(s.begin(), s.end());
+        sort(t.begin(), t.end());
+        return s == t;
+    }
+    
+    //using a map to count every chars in the string.
+    bool isAnagram02(string s, string t) {
+        int map[26] ={0} ; //only lowercase alphabets
+        //memset(map, 0, sizeof(map));
+        
+        // count each char for s
+        for (int i=0; i<s.size(); i++) {
+            map[s[i]-'a']++;
+        }
+        // decrease the count for t
+        for (int i=0; i<t.size(); i++) {
+            map[t[i]-'a']--;
+        }
+        
+        //if all alphabets is zero, then they are anagram 
+        for (int i=0; i<sizeof(map)/sizeof(map[0]); i++) {
+            if (map[i]!=0) return false;
+        }
+        return true;
+    }
+    
+
+    
+    bool isAnagram(string s, string t) {
+        return isAnagram02(s,t); //12ms
+        return isAnagram01(s,t); //76ms
+    }
+    
+};
+
+
+
@@ -0,0 +1,108 @@
+// Source : https://leetcode.com/problems/different-ways-to-add-parentheses/
+// Author : Hao Chen
+// Date   : 2015-08-15
+
+/********************************************************************************** 
+ * 
+ * Given a string of numbers and operators, return all possible results from computing 
+ * all the different possible ways to group numbers and operators. The valid operators 
+ * are +, - and *.
+ * 
+ * Example 1
+ * Input: "2-1-1". 
+ * ((2-1)-1) = 0
+ * (2-(1-1)) = 2
+ * Output: [0, 2]
+ * 
+ * Example 2
+ * Input: "2*3-4*5" 
+ * (2*(3-(4*5))) = -34
+ * ((2*3)-(4*5)) = -14
+ * ((2*(3-4))*5) = -10
+ * (2*((3-4)*5)) = -10
+ * (((2*3)-4)*5) = 10
+ * Output: [-34, -14, -10, -10, 10] 
+ * 
+ * Credits:Special thanks to @mithmatt for adding this problem and creating all test 
+ * cases.
+ *               
+ **********************************************************************************/
+#include <stdlib.h>
+#include <ctype.h>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <map>
+using namespace std;
+
+
+bool isOperator(char ch){
+    return (ch=='+' || ch=='-' || ch=='*');
+}
+
+
+//Divide & Conque  - recursive way
+vector<int> diffWaysToCompute(string input) {
+    //if the result has been cacluated, then just get it from the cache and return 
+    static map< string, vector<int> > cache;
+    if ( cache.find(input) != cache.end() ){
+        return cache[input];
+    }
+
+
+    vector<int> result; 
+    for (int i=0; i<input.size(); i++){
+        char ch = input[i];
+        if (isOperator(ch)){
+            //split the input to two parts, left part and right part 
+            //And recursively invoke this function.
+            string left  = input.substr(0, i);
+            string right = input.substr(i+1);
+            vector<int> lv = diffWaysToCompute(left);
+            vector<int> rv = diffWaysToCompute(right);
+
+            //merge two result to one
+            for(int li=0; li<lv.size(); li++) {
+                for(int ri=0; ri<rv.size(); ri++) {
+                    switch(ch){
+                        case '+' : result.push_back(lv[li] + rv[ri]); break;
+                        case '-' : result.push_back(lv[li] - rv[ri]); break;
+                        case '*' : result.push_back(lv[li] * rv[ri]); break;
+                    }
+                }
+            }
+
+        }
+    }
+    //if we cannot find the "operator" in input, 
+    //which means, it is a number, just put the number into the result. 
+    if (result.size()==0) {
+        result.push_back(atoi(input.c_str()));
+    }
+    
+    //cache the result, key = input, value = result;
+    cache[input] = result;
+
+    return result;
+}
+
+void printVector(vector<int>& v) {
+    cout << "[";
+    for(int i=0; i<v.size(); i++) {
+        cout << v[i] << (i==v.size()-1 ? "]":", ");
+    }
+    cout << endl;
+}
+
+int main(int argc, char**argv) 
+{
+    string exp = "2*3-4*5";
+    if ( argc > 1 ){
+        exp = argv[1];
+    }
+    vector<int> v = diffWaysToCompute(exp);
+    cout << exp << endl;
+    printVector(v);
+    return 0;
+}
+
@@ -13,10 +13,10 @@
  * 
  * Example: 19 is a happy number
  * 
- * 12 + 92 = 82
- * 82 + 22 = 68
- * 62 + 82 = 100
- * 12 + 02 + 02 = 1
+ * 1^2 + 9^2 = 82
+ * 8^2 + 2^2 = 68
+ * 6^2 + 8^2 = 100
+ * 1^2 + 0^2 + 0^2 = 1
  * 
  * Credits:Special thanks to @mithmatt and @ts for adding this problem and creating all test cases.
  *
Original file line number	Diff line number	Diff line change
`@@ -13,10 +13,10 @@`
`13`	`13`	`*`
`14`	`14`	`* Example: 19 is a happy number`
`15`	`15`	`*`
`16`		`- * 12 + 92 = 82`
`17`		`- * 82 + 22 = 68`
`18`		`- * 62 + 82 = 100`
`19`		`- * 12 + 02 + 02 = 1`
	`16`	`+ * 1^2 + 9^2 = 82`
	`17`	`+ * 8^2 + 2^2 = 68`
	`18`	`+ * 6^2 + 8^2 = 100`
	`19`	`+ * 1^2 + 0^2 + 0^2 = 1`
`20`	`20`	`*`
`21`	`21`	`* Credits:Special thanks to @mithmatt and @ts for adding this problem and creating all test cases.`
`22`	`22`	`*`