From 6495e14da0a6bb7b48bfcd90eaf4b290807f971d Mon Sep 17 00:00:00 2001
From: Ciro Santilli <ciro.santilli@gmail.com>
Date: Thu, 10 Dec 2015 07:29:24 -0200
Subject: [PATCH 01/54] gitignore java *.class files for those without IDE

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 1f1c65c40..25a4d2a65 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 .idea
 algorithms-java/out
+*.class

From cc7fc84f38679f8808f92a3ac77f2e0117fffb24 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ciro=20Santilli=20=E5=85=AD=E5=9B=9B=E4=BA=8B=E4=BB=B6=20?=
 =?UTF-8?q?=E6=B3=95=E8=BD=AE=E5=8A=9F?= <ciro.santilli@gmail.com>
Date: Thu, 10 Dec 2015 07:29:24 -0200
Subject: [PATCH 02/54] gitignore java *.class files for those without IDE

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 1f1c65c40..25a4d2a65 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 .idea
 algorithms-java/out
+*.class

From 728ad252ab04b5ee0d6817d7ef6c9c724f9f71b5 Mon Sep 17 00:00:00 2001
From: Ciro Santilli <ciro.santilli@gmail.com>
Date: Thu, 10 Dec 2015 07:21:27 -0200
Subject: [PATCH 03/54] java LRUCache with LinkedHashMap

---
 algorithms/java/src/lruCache/LRUCache.java    | 45 +++++++++++++++++
 .../java/src/lruCache/LRUCacheTest.java       | 49 +++++++++++++++++++
 2 files changed, 94 insertions(+)
 create mode 100644 algorithms/java/src/lruCache/LRUCache.java
 create mode 100644 algorithms/java/src/lruCache/LRUCacheTest.java

diff --git a/algorithms/java/src/lruCache/LRUCache.java b/algorithms/java/src/lruCache/LRUCache.java
new file mode 100644
index 000000000..5ea5c2950
--- /dev/null
+++ b/algorithms/java/src/lruCache/LRUCache.java
@@ -0,0 +1,45 @@
+/*
+Analogous to the C++ solution at:
+https://github.com/haoel/leetcode/blob/625ad10464701fc4177b9ef33c8ad052d0a7d984/algorithms/cpp/LRUCache/LRUCache.cpp
+which uses linked list + hash map. But the Java stdlib provides LinkedHashMap
+which already implements that for us, making this solution shorter.
+
+This could also be done by using, but that generates
+some inheritance boilerplate, and ends up taking the same number of lines:
+https://github.com/cirosantilli/haoel-leetcode/commit/ff04930b2dc31f270854e40b560723577c7b49fd
+*/
+
+import java.util.LinkedHashMap;
+import java.util.Iterator;
+
+public class LRUCache {
+
+    private int capacity;
+    private LinkedHashMap<Integer,Integer> map;
+
+    public LRUCache(int capacity) {
+        this.capacity = capacity;
+        this.map = new LinkedHashMap<>();
+    }
+
+    public int get(int key) {
+        Integer value = this.map.get(key);
+        if (value == null) {
+            value = -1;
+        } else {
+            this.set(key, value);
+        }
+        return value;
+    }
+
+    public void set(int key, int value) {
+        if (this.map.containsKey(key)) {
+            this.map.remove(key);
+        } else if (this.map.size() == this.capacity) {
+            Iterator<Integer> it = this.map.keySet().iterator();
+            it.next();
+            it.remove();
+        }
+        map.put(key, value);
+    }
+}
diff --git a/algorithms/java/src/lruCache/LRUCacheTest.java b/algorithms/java/src/lruCache/LRUCacheTest.java
new file mode 100644
index 000000000..b8166873e
--- /dev/null
+++ b/algorithms/java/src/lruCache/LRUCacheTest.java
@@ -0,0 +1,49 @@
+import java.util.ArrayList;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LRUCacheTest {
+
+    private LRUCache c;
+
+    public LRUCacheTest() {
+        this.c = new LRUCache(2);
+    }
+
+    @Test
+    public void testCacheStartsEmpty() {
+        assertEquals(c.get(1), -1);
+    }
+
+    @Test
+    public void testSetBelowCapacity() {
+        c.set(1, 1);
+        assertEquals(c.get(1), 1);
+        assertEquals(c.get(2), -1);
+        c.set(2, 4);
+        assertEquals(c.get(1), 1);
+        assertEquals(c.get(2), 4);
+    }
+
+    @Test
+    public void testCapacityReachedOldestRemoved() {
+        c.set(1, 1);
+        c.set(2, 4);
+        c.set(3, 9);
+        assertEquals(c.get(1), -1);
+        assertEquals(c.get(2), 4);
+        assertEquals(c.get(3), 9);
+    }
+
+    @Test
+    public void testGetRenewsEntry() {
+        c.set(1, 1);
+        c.set(2, 4);
+        assertEquals(c.get(1), 1);
+        c.set(3, 9);
+        assertEquals(c.get(1), 1);
+        assertEquals(c.get(2), -1);
+        assertEquals(c.get(3), 9);
+    }
+}

From 2a8222328fa9d677f26059a09602a10c7b1a029d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ciro=20Santilli=20=E5=85=AD=E5=9B=9B=E4=BA=8B=E4=BB=B6=20?=
 =?UTF-8?q?=E6=B3=95=E8=BD=AE=E5=8A=9F?= <ciro.santilli@gmail.com>
Date: Thu, 10 Dec 2015 07:21:27 -0200
Subject: [PATCH 04/54] java LRUCache with LinkedHashMap

---
 algorithms/java/src/lruCache/LRUCache.java    | 45 +++++++++++++++++
 .../java/src/lruCache/LRUCacheTest.java       | 49 +++++++++++++++++++
 2 files changed, 94 insertions(+)
 create mode 100644 algorithms/java/src/lruCache/LRUCache.java
 create mode 100644 algorithms/java/src/lruCache/LRUCacheTest.java

diff --git a/algorithms/java/src/lruCache/LRUCache.java b/algorithms/java/src/lruCache/LRUCache.java
new file mode 100644
index 000000000..5ea5c2950
--- /dev/null
+++ b/algorithms/java/src/lruCache/LRUCache.java
@@ -0,0 +1,45 @@
+/*
+Analogous to the C++ solution at:
+https://github.com/haoel/leetcode/blob/625ad10464701fc4177b9ef33c8ad052d0a7d984/algorithms/cpp/LRUCache/LRUCache.cpp
+which uses linked list + hash map. But the Java stdlib provides LinkedHashMap
+which already implements that for us, making this solution shorter.
+
+This could also be done by using, but that generates
+some inheritance boilerplate, and ends up taking the same number of lines:
+https://github.com/cirosantilli/haoel-leetcode/commit/ff04930b2dc31f270854e40b560723577c7b49fd
+*/
+
+import java.util.LinkedHashMap;
+import java.util.Iterator;
+
+public class LRUCache {
+
+    private int capacity;
+    private LinkedHashMap<Integer,Integer> map;
+
+    public LRUCache(int capacity) {
+        this.capacity = capacity;
+        this.map = new LinkedHashMap<>();
+    }
+
+    public int get(int key) {
+        Integer value = this.map.get(key);
+        if (value == null) {
+            value = -1;
+        } else {
+            this.set(key, value);
+        }
+        return value;
+    }
+
+    public void set(int key, int value) {
+        if (this.map.containsKey(key)) {
+            this.map.remove(key);
+        } else if (this.map.size() == this.capacity) {
+            Iterator<Integer> it = this.map.keySet().iterator();
+            it.next();
+            it.remove();
+        }
+        map.put(key, value);
+    }
+}
diff --git a/algorithms/java/src/lruCache/LRUCacheTest.java b/algorithms/java/src/lruCache/LRUCacheTest.java
new file mode 100644
index 000000000..b8166873e
--- /dev/null
+++ b/algorithms/java/src/lruCache/LRUCacheTest.java
@@ -0,0 +1,49 @@
+import java.util.ArrayList;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LRUCacheTest {
+
+    private LRUCache c;
+
+    public LRUCacheTest() {
+        this.c = new LRUCache(2);
+    }
+
+    @Test
+    public void testCacheStartsEmpty() {
+        assertEquals(c.get(1), -1);
+    }
+
+    @Test
+    public void testSetBelowCapacity() {
+        c.set(1, 1);
+        assertEquals(c.get(1), 1);
+        assertEquals(c.get(2), -1);
+        c.set(2, 4);
+        assertEquals(c.get(1), 1);
+        assertEquals(c.get(2), 4);
+    }
+
+    @Test
+    public void testCapacityReachedOldestRemoved() {
+        c.set(1, 1);
+        c.set(2, 4);
+        c.set(3, 9);
+        assertEquals(c.get(1), -1);
+        assertEquals(c.get(2), 4);
+        assertEquals(c.get(3), 9);
+    }
+
+    @Test
+    public void testGetRenewsEntry() {
+        c.set(1, 1);
+        c.set(2, 4);
+        assertEquals(c.get(1), 1);
+        c.set(3, 9);
+        assertEquals(c.get(1), 1);
+        assertEquals(c.get(2), -1);
+        assertEquals(c.get(3), 9);
+    }
+}

From 738bc45ec9969f4bc7ca0a11394b7cd06243090d Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Mon, 28 Dec 2015 18:36:22 +0200
Subject: [PATCH 05/54] added bulbSwitcher

---
 README.md                                    |  1 +
 algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp | 44 ++++++++++++++++++++
 2 files changed, 45 insertions(+)
 create mode 100644 algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp

diff --git a/README.md b/README.md
index 3f71fe9be..fc0f24320 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
 |307|[Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/) | [C++](./algorithms/cpp/rangeSumQuery-Immutable/rangeSumQuery-Mutable/RangeSumQueryMutable.cpp)|Medium|
 |306|[Additive Number](https://leetcode.com/problems/additive-number/) | [C++](./algorithms/cpp/additiveNumber/AdditiveNumber.cpp)|Medium|
diff --git a/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp b/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp
new file mode 100644
index 000000000..04b046391
--- /dev/null
+++ b/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp
@@ -0,0 +1,44 @@
+// Source : https://leetcode.com/problems/bulb-switcher/
+// Author : Calinescu Valentin
+// Date   : 2015-12-28
+
+/*************************************************************************************** 
+ *
+ * There are n bulbs that are initially off. You first turn on all the bulbs. Then, you
+ * turn off every second bulb. On the third round, you toggle every third bulb (turning
+ * on if it's off or turning off if it's on). For the nth round, you only toggle the
+ * last bulb. Find how many bulbs are on after n rounds.
+ * 
+ * Example:
+ * 
+ * Given n = 3. 
+ * 
+ * At first, the three bulbs are [off, off, off].
+ * After first round, the three bulbs are [on, on, on].
+ * After second round, the three bulbs are [on, off, on].
+ * After third round, the three bulbs are [on, off, off]. 
+ * 
+ * So you should return 1, because there is only one bulb is on.
+ * 
+ ***************************************************************************************/
+ /* 
+ * Solution 1 - O(1)
+ * =========
+ *
+ * We notice that for every light bulb on position i there will be one toggle for every
+ * one of its divisors, given that you toggle all of the multiples of one number. The 
+ * total number of toggles is irrelevant, because there are only 2 possible positions(on, 
+ * off). We quickly find that 2 toggles cancel each other so given that the start position
+ * is always off a light bulb will be in if it has been toggled an odd number of times.
+ * The only integers with an odd number of divisors are perfect squares(because the square
+ * root only appears once, not like the other divisors that form pairs). The problem comes
+ * down to finding the number of perfect squares <= n. That number is the integer part of
+ * the square root of n.
+ * 
+ */
+class Solution {
+public:
+    int bulbSwitch(int n) {
+        return (int)sqrt(n);
+    }
+};

From a6368c99b3a1edc99489a152a54d849d10a913fc Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Mon, 28 Dec 2015 18:36:22 +0200
Subject: [PATCH 06/54] added bulbSwitcher

---
 README.md                                    |  1 +
 algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp | 44 ++++++++++++++++++++
 2 files changed, 45 insertions(+)
 create mode 100644 algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp

diff --git a/README.md b/README.md
index 3f71fe9be..fc0f24320 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
 |307|[Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/) | [C++](./algorithms/cpp/rangeSumQuery-Immutable/rangeSumQuery-Mutable/RangeSumQueryMutable.cpp)|Medium|
 |306|[Additive Number](https://leetcode.com/problems/additive-number/) | [C++](./algorithms/cpp/additiveNumber/AdditiveNumber.cpp)|Medium|
diff --git a/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp b/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp
new file mode 100644
index 000000000..04b046391
--- /dev/null
+++ b/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp
@@ -0,0 +1,44 @@
+// Source : https://leetcode.com/problems/bulb-switcher/
+// Author : Calinescu Valentin
+// Date   : 2015-12-28
+
+/*************************************************************************************** 
+ *
+ * There are n bulbs that are initially off. You first turn on all the bulbs. Then, you
+ * turn off every second bulb. On the third round, you toggle every third bulb (turning
+ * on if it's off or turning off if it's on). For the nth round, you only toggle the
+ * last bulb. Find how many bulbs are on after n rounds.
+ * 
+ * Example:
+ * 
+ * Given n = 3. 
+ * 
+ * At first, the three bulbs are [off, off, off].
+ * After first round, the three bulbs are [on, on, on].
+ * After second round, the three bulbs are [on, off, on].
+ * After third round, the three bulbs are [on, off, off]. 
+ * 
+ * So you should return 1, because there is only one bulb is on.
+ * 
+ ***************************************************************************************/
+ /* 
+ * Solution 1 - O(1)
+ * =========
+ *
+ * We notice that for every light bulb on position i there will be one toggle for every
+ * one of its divisors, given that you toggle all of the multiples of one number. The 
+ * total number of toggles is irrelevant, because there are only 2 possible positions(on, 
+ * off). We quickly find that 2 toggles cancel each other so given that the start position
+ * is always off a light bulb will be in if it has been toggled an odd number of times.
+ * The only integers with an odd number of divisors are perfect squares(because the square
+ * root only appears once, not like the other divisors that form pairs). The problem comes
+ * down to finding the number of perfect squares <= n. That number is the integer part of
+ * the square root of n.
+ * 
+ */
+class Solution {
+public:
+    int bulbSwitch(int n) {
+        return (int)sqrt(n);
+    }
+};

From cc1f6554dedcdb0b8aab5b339d5ad2604733e70a Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Mon, 28 Dec 2015 19:44:50 +0200
Subject: [PATCH 07/54] added coinChange

---
 README.md                                |  1 +
 algorithms/cpp/coinChange/coinChange.cpp | 62 ++++++++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 algorithms/cpp/coinChange/coinChange.cpp

diff --git a/README.md b/README.md
index fc0f24320..539f6b37d 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
 |307|[Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/) | [C++](./algorithms/cpp/rangeSumQuery-Immutable/rangeSumQuery-Mutable/RangeSumQueryMutable.cpp)|Medium|
diff --git a/algorithms/cpp/coinChange/coinChange.cpp b/algorithms/cpp/coinChange/coinChange.cpp
new file mode 100644
index 000000000..e8ddc9c51
--- /dev/null
+++ b/algorithms/cpp/coinChange/coinChange.cpp
@@ -0,0 +1,62 @@
+// Source : https://leetcode.com/problems/coin-change/
+// Author : Calinescu Valentin
+// Date   : 2015-12-28
+
+/*************************************************************************************** 
+ *
+ * You are given coins of different denominations and a total amount of money amount. 
+ * Write a function to compute the fewest number of coins that you need to make up that
+ * amount. If that amount of money cannot be made up by any combination of the coins,
+ * return -1.
+ * 
+ * Example 1:
+ * coins = [1, 2, 5], amount = 11
+ * return 3 (11 = 5 + 5 + 1)
+ * 
+ * Example 2:
+ * coins = [2], amount = 3
+ * return -1.
+ * 
+ * Note:
+ * You may assume that you have an infinite number of each kind of coin.
+ * 
+ * Credits:
+ * Special thanks to @jianchao.li.fighter for adding this problem and creating all test 
+ * cases.
+ * 
+ ***************************************************************************************/
+ /* 
+ * Solution 1 - O(N * amount)
+ * =========
+ *
+ * This problem can be solved using dynamic programming, thus building the optimal
+ * solution from previous smaller ones. For every coin of value t and every sum of money
+ * i the sum can be traced back to a previous sum i - t that was already computed and uses
+ * the smallest number of coins possible. This way we can construct every sum i as the
+ * minimum of all these previous sums for every coin value. To be sure we'll find a minimum
+ * we can populate the solution vector with an amount bigger than the maximum possible, 
+ * which is amount + 1(when the sum is made up of only coins of value 1). The only exception
+ * is sol[0] which is 0 as we need 0 coins to have a sum of 0. In the end we need to look
+ * if the program found a solution in sol[amount] or it remained the same, in which case we
+ * can return -1.
+ * 
+ */
+class Solution {
+public:
+    
+    int coinChange(vector<int>& coins, int amount) {
+        int sol[amount + 1];
+        sol[0] = 0;
+        for(int i = 1; i <= amount; i++)
+            sol[i] = amount + 1;
+        for(int i = 0; i < coins.size(); i++)
+        {
+            for(int j = coins[i]; j <= amount; j++)
+                sol[j] = min(sol[j], sol[j - coins[i]] + 1);
+        }
+        if(sol[amount] != amount + 1)
+            return sol[amount];
+        else
+            return -1;
+    }
+};

From 7c7528fbc4b1805c47428fe7cce6fb9bfc9a7565 Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Mon, 28 Dec 2015 19:44:50 +0200
Subject: [PATCH 08/54] added coinChange

---
 README.md                                |  1 +
 algorithms/cpp/coinChange/coinChange.cpp | 62 ++++++++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 algorithms/cpp/coinChange/coinChange.cpp

diff --git a/README.md b/README.md
index fc0f24320..539f6b37d 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
 |307|[Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/) | [C++](./algorithms/cpp/rangeSumQuery-Immutable/rangeSumQuery-Mutable/RangeSumQueryMutable.cpp)|Medium|
diff --git a/algorithms/cpp/coinChange/coinChange.cpp b/algorithms/cpp/coinChange/coinChange.cpp
new file mode 100644
index 000000000..e8ddc9c51
--- /dev/null
+++ b/algorithms/cpp/coinChange/coinChange.cpp
@@ -0,0 +1,62 @@
+// Source : https://leetcode.com/problems/coin-change/
+// Author : Calinescu Valentin
+// Date   : 2015-12-28
+
+/*************************************************************************************** 
+ *
+ * You are given coins of different denominations and a total amount of money amount. 
+ * Write a function to compute the fewest number of coins that you need to make up that
+ * amount. If that amount of money cannot be made up by any combination of the coins,
+ * return -1.
+ * 
+ * Example 1:
+ * coins = [1, 2, 5], amount = 11
+ * return 3 (11 = 5 + 5 + 1)
+ * 
+ * Example 2:
+ * coins = [2], amount = 3
+ * return -1.
+ * 
+ * Note:
+ * You may assume that you have an infinite number of each kind of coin.
+ * 
+ * Credits:
+ * Special thanks to @jianchao.li.fighter for adding this problem and creating all test 
+ * cases.
+ * 
+ ***************************************************************************************/
+ /* 
+ * Solution 1 - O(N * amount)
+ * =========
+ *
+ * This problem can be solved using dynamic programming, thus building the optimal
+ * solution from previous smaller ones. For every coin of value t and every sum of money
+ * i the sum can be traced back to a previous sum i - t that was already computed and uses
+ * the smallest number of coins possible. This way we can construct every sum i as the
+ * minimum of all these previous sums for every coin value. To be sure we'll find a minimum
+ * we can populate the solution vector with an amount bigger than the maximum possible, 
+ * which is amount + 1(when the sum is made up of only coins of value 1). The only exception
+ * is sol[0] which is 0 as we need 0 coins to have a sum of 0. In the end we need to look
+ * if the program found a solution in sol[amount] or it remained the same, in which case we
+ * can return -1.
+ * 
+ */
+class Solution {
+public:
+    
+    int coinChange(vector<int>& coins, int amount) {
+        int sol[amount + 1];
+        sol[0] = 0;
+        for(int i = 1; i <= amount; i++)
+            sol[i] = amount + 1;
+        for(int i = 0; i < coins.size(); i++)
+        {
+            for(int j = coins[i]; j <= amount; j++)
+                sol[j] = min(sol[j], sol[j - coins[i]] + 1);
+        }
+        if(sol[amount] != amount + 1)
+            return sol[amount];
+        else
+            return -1;
+    }
+};

From 38f5b0b655c65eca4a6d1fb6bd65776e0112ad06 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Thu, 14 Jan 2016 09:31:58 +0800
Subject: [PATCH 09/54] typo

---
 .../findMinimumInRotatedSortedArray.cpp                         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp b/algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp
index 2ac3e33a3..9c8cc43cb 100644
--- a/algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp
+++ b/algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp
@@ -38,7 +38,7 @@ int findMin(vector<int> &num) {
         }
 
         // The array is rotated
-        // Spli it into two part, the minimal value must be the rotated part
+        // Split it into two part, the minimal value must be the rotated part
         
         // if the left part is rotated, warch the left part
         if (num[low] > num [mid]){

From e8d5796753a79cabf44fbd635033be0918c0aafd Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Thu, 14 Jan 2016 09:31:58 +0800
Subject: [PATCH 10/54] typo

---
 .../findMinimumInRotatedSortedArray.cpp                         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp b/algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp
index 2ac3e33a3..9c8cc43cb 100644
--- a/algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp
+++ b/algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp
@@ -38,7 +38,7 @@ int findMin(vector<int> &num) {
         }
 
         // The array is rotated
-        // Spli it into two part, the minimal value must be the rotated part
+        // Split it into two part, the minimal value must be the rotated part
         
         // if the left part is rotated, warch the left part
         if (num[low] > num [mid]){

From be27a989a5e0f330f0936b68835c31921edc9c54 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Thu, 14 Jan 2016 09:32:20 +0800
Subject: [PATCH 11/54] New Problem "Power of Three"

---
 README.md                                    |  1 +
 algorithms/cpp/powerOfThree/PowerOfThree.cpp | 66 ++++++++++++++++++++
 2 files changed, 67 insertions(+)
 create mode 100644 algorithms/cpp/powerOfThree/PowerOfThree.cpp

diff --git a/README.md b/README.md
index 539f6b37d..67b0f1199 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|326|[Power of Three](https://leetcode.com/problems/power-of-three/) | [C++](./algorithms/cpp/powerOfThree/PowerOfThree.cpp)|Easy|
 |322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
diff --git a/algorithms/cpp/powerOfThree/PowerOfThree.cpp b/algorithms/cpp/powerOfThree/PowerOfThree.cpp
new file mode 100644
index 000000000..a75143b91
--- /dev/null
+++ b/algorithms/cpp/powerOfThree/PowerOfThree.cpp
@@ -0,0 +1,66 @@
+// Source : https://leetcode.com/problems/power-of-three/
+// Author : Hao Chen
+// Date   : 2016-01-14
+
+/*************************************************************************************** 
+ *
+ * Given an integer, write a function to determine if it is a power of three.
+ * 
+ *     Follow up:
+ *     Could you do it without using any loop / recursion?
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ *               
+ ***************************************************************************************/
+
+class Solution {
+
+public:
+    
+    bool isPowerOfThree(int n) {
+        return isPowerOfThree03(n); //140ms
+        return isPowerOfThree02(n);//130ms
+        return isPowerOfThree01(n); //140ms
+        return isPowerOfThree_loop(n);  //136ms
+        return isPowerOfThree_recursive(n); //168ms
+    }
+    
+    bool isPowerOfThree03(int n) {
+        double logRes = log10(n)/log10(3); 
+        return (logRes - int(logRes) == 0);
+    }
+    bool isPowerOfThree02(int n) {
+        return n>0 ? (1162261467%n==0) : false;
+    }
+    
+    void init(unordered_map<int, bool>& power ){
+        int p = 1;
+        power[1]=true;
+        while(1){
+            p *= 3;
+            power[p] = true;
+            if (p > INT_MAX/3) break;
+            
+        }
+    }
+    bool isPowerOfThree01(int n) {
+        static unordered_map<int, bool> power; 
+        if (power.size()==0) init(power);
+        return power.find(n) != power.end();
+    }
+    
+    bool isPowerOfThree_loop(int n) {
+        for(;n>0;n /= 3){
+            if (n==1 || n==3) return true;
+            if (n%3 != 0) return false;
+        }
+        return false;
+    }
+    
+    bool isPowerOfThree_recursive(int n) {
+        if ( n == 1 || n == 3) return true;
+        if ( n==0 || n%3 != 0 ) return false;
+        return isPowerOfThree_recursive(n/3);
+    } 
+};

From 73279a1a75af7011a864e6c2d496fe3df0162e98 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Thu, 14 Jan 2016 09:32:20 +0800
Subject: [PATCH 12/54] New Problem "Power of Three"

---
 README.md                                    |  1 +
 algorithms/cpp/powerOfThree/PowerOfThree.cpp | 66 ++++++++++++++++++++
 2 files changed, 67 insertions(+)
 create mode 100644 algorithms/cpp/powerOfThree/PowerOfThree.cpp

diff --git a/README.md b/README.md
index 539f6b37d..67b0f1199 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|326|[Power of Three](https://leetcode.com/problems/power-of-three/) | [C++](./algorithms/cpp/powerOfThree/PowerOfThree.cpp)|Easy|
 |322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
diff --git a/algorithms/cpp/powerOfThree/PowerOfThree.cpp b/algorithms/cpp/powerOfThree/PowerOfThree.cpp
new file mode 100644
index 000000000..a75143b91
--- /dev/null
+++ b/algorithms/cpp/powerOfThree/PowerOfThree.cpp
@@ -0,0 +1,66 @@
+// Source : https://leetcode.com/problems/power-of-three/
+// Author : Hao Chen
+// Date   : 2016-01-14
+
+/*************************************************************************************** 
+ *
+ * Given an integer, write a function to determine if it is a power of three.
+ * 
+ *     Follow up:
+ *     Could you do it without using any loop / recursion?
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ *               
+ ***************************************************************************************/
+
+class Solution {
+
+public:
+    
+    bool isPowerOfThree(int n) {
+        return isPowerOfThree03(n); //140ms
+        return isPowerOfThree02(n);//130ms
+        return isPowerOfThree01(n); //140ms
+        return isPowerOfThree_loop(n);  //136ms
+        return isPowerOfThree_recursive(n); //168ms
+    }
+    
+    bool isPowerOfThree03(int n) {
+        double logRes = log10(n)/log10(3); 
+        return (logRes - int(logRes) == 0);
+    }
+    bool isPowerOfThree02(int n) {
+        return n>0 ? (1162261467%n==0) : false;
+    }
+    
+    void init(unordered_map<int, bool>& power ){
+        int p = 1;
+        power[1]=true;
+        while(1){
+            p *= 3;
+            power[p] = true;
+            if (p > INT_MAX/3) break;
+            
+        }
+    }
+    bool isPowerOfThree01(int n) {
+        static unordered_map<int, bool> power; 
+        if (power.size()==0) init(power);
+        return power.find(n) != power.end();
+    }
+    
+    bool isPowerOfThree_loop(int n) {
+        for(;n>0;n /= 3){
+            if (n==1 || n==3) return true;
+            if (n%3 != 0) return false;
+        }
+        return false;
+    }
+    
+    bool isPowerOfThree_recursive(int n) {
+        if ( n == 1 || n == 3) return true;
+        if ( n==0 || n%3 != 0 ) return false;
+        return isPowerOfThree_recursive(n/3);
+    } 
+};

From 7b084c822038e474e2a595cf46af31f860a19917 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Fri, 15 Jan 2016 15:03:32 +0800
Subject: [PATCH 13/54] another solution

---
 .../countOfSmallerNumbersAfterSelf.cpp        | 79 ++++++++++++++++++-
 1 file changed, 78 insertions(+), 1 deletion(-)

diff --git a/algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp b/algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp
index cac1435c4..badec47d2 100644
--- a/algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp
+++ b/algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp
@@ -1,5 +1,5 @@
 // Source : https://leetcode.com/problems/count-of-smaller-numbers-after-self/
-// Author : Calinescu Valentin
+// Author : Calinescu Valentin, Hao Chen
 // Date   : 2015-12-08
 
 /*************************************************************************************** 
@@ -73,3 +73,80 @@ class Solution {
         return sol;
     }
 };
+
+
+/*************************************************************************************** 
+ * Another solution - Binary Search Tree
+ ***************************************************************************************/
+
+
+class BinarySearchTreeNode
+{
+    public:
+        int val;     
+        int less;      // count of members less than val
+        int count;     // count of members equal val
+        BinarySearchTreeNode *left, *right;
+        BinarySearchTreeNode(int value) : val(value), less(0),count(1),left(NULL), right(NULL) {}
+};
+
+class BinarySearchTree
+{
+    private:
+        BinarySearchTreeNode* root;
+    public:
+        BinarySearchTree(const int value):root(new BinarySearchTreeNode(value)){ }
+        ~BinarySearchTree() {
+            freeTree(root);
+        }
+        void insert(const int value, int &numLessThan) {
+            insert(root, value, numLessThan);
+        }
+    private:
+        void freeTree(BinarySearchTreeNode* root){
+            if (root == NULL) return;
+            if (root->left) freeTree(root->left);
+            if (root->right) freeTree(root->right);
+            delete root;
+        }
+
+        void insert(BinarySearchTreeNode* root, const int value, int &numLessThan) {
+
+            if(value < root->val) {  // left
+                root->less++;
+                if(root->left == NULL) {
+                    root->left = new BinarySearchTreeNode(value);
+                }else{
+                    this->insert(root->left, value, numLessThan);
+                }
+            } else if(value > root->val) { // right
+                numLessThan += root->less + root->count;
+                if(!root->right) {
+                    root->right = new BinarySearchTreeNode(value);
+                }else{
+                    this->insert(root->right, value, numLessThan);
+                }
+            } else {
+                numLessThan += root->less;
+                root->count++;
+                return;
+            }
+        }
+};
+
+class Solution {
+    public:
+        vector<int> countSmaller(vector<int>& nums) {
+            vector<int> counts(nums.size());
+            if(nums.size() == 0) return counts;
+
+            BinarySearchTree tree(nums[nums.size()-1]);
+
+            for(int i = nums.size() - 2; i >= 0; i--) {
+                int numLessThan = 0;
+                tree.insert( nums[i], numLessThan);
+                counts[i] = numLessThan;
+            }
+            return counts; 
+        }
+};

From 12450188eceacab8e98e2ab1c02027e4ae380d9b Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Fri, 15 Jan 2016 15:03:32 +0800
Subject: [PATCH 14/54] another solution

---
 .../countOfSmallerNumbersAfterSelf.cpp        | 79 ++++++++++++++++++-
 1 file changed, 78 insertions(+), 1 deletion(-)

diff --git a/algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp b/algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp
index cac1435c4..badec47d2 100644
--- a/algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp
+++ b/algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp
@@ -1,5 +1,5 @@
 // Source : https://leetcode.com/problems/count-of-smaller-numbers-after-self/
-// Author : Calinescu Valentin
+// Author : Calinescu Valentin, Hao Chen
 // Date   : 2015-12-08
 
 /*************************************************************************************** 
@@ -73,3 +73,80 @@ class Solution {
         return sol;
     }
 };
+
+
+/*************************************************************************************** 
+ * Another solution - Binary Search Tree
+ ***************************************************************************************/
+
+
+class BinarySearchTreeNode
+{
+    public:
+        int val;     
+        int less;      // count of members less than val
+        int count;     // count of members equal val
+        BinarySearchTreeNode *left, *right;
+        BinarySearchTreeNode(int value) : val(value), less(0),count(1),left(NULL), right(NULL) {}
+};
+
+class BinarySearchTree
+{
+    private:
+        BinarySearchTreeNode* root;
+    public:
+        BinarySearchTree(const int value):root(new BinarySearchTreeNode(value)){ }
+        ~BinarySearchTree() {
+            freeTree(root);
+        }
+        void insert(const int value, int &numLessThan) {
+            insert(root, value, numLessThan);
+        }
+    private:
+        void freeTree(BinarySearchTreeNode* root){
+            if (root == NULL) return;
+            if (root->left) freeTree(root->left);
+            if (root->right) freeTree(root->right);
+            delete root;
+        }
+
+        void insert(BinarySearchTreeNode* root, const int value, int &numLessThan) {
+
+            if(value < root->val) {  // left
+                root->less++;
+                if(root->left == NULL) {
+                    root->left = new BinarySearchTreeNode(value);
+                }else{
+                    this->insert(root->left, value, numLessThan);
+                }
+            } else if(value > root->val) { // right
+                numLessThan += root->less + root->count;
+                if(!root->right) {
+                    root->right = new BinarySearchTreeNode(value);
+                }else{
+                    this->insert(root->right, value, numLessThan);
+                }
+            } else {
+                numLessThan += root->less;
+                root->count++;
+                return;
+            }
+        }
+};
+
+class Solution {
+    public:
+        vector<int> countSmaller(vector<int>& nums) {
+            vector<int> counts(nums.size());
+            if(nums.size() == 0) return counts;
+
+            BinarySearchTree tree(nums[nums.size()-1]);
+
+            for(int i = nums.size() - 2; i >= 0; i--) {
+                int numLessThan = 0;
+                tree.insert( nums[i], numLessThan);
+                counts[i] = numLessThan;
+            }
+            return counts; 
+        }
+};

From b430d99d3bbd9c57b8b11b548a88b58fafb0d5c9 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Fri, 15 Jan 2016 22:42:31 +0800
Subject: [PATCH 15/54] New Problem "Count of Range Sum"

---
 README.md                                     |   1 +
 .../cpp/countOfRangeSum/CountOfRangeSum.cpp   | 163 ++++++++++++++++++
 2 files changed, 164 insertions(+)
 create mode 100644 algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp

diff --git a/README.md b/README.md
index cfee4ebf2..c4c976e14 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|327|[Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/) | [C++](./algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp)|Hard|
 |326|[Power of Three](https://leetcode.com/problems/power-of-three/) | [C++](./algorithms/cpp/powerOfThree/PowerOfThree.cpp)|Easy|
 |322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
diff --git a/algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp b/algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp
new file mode 100644
index 000000000..81b1f21bb
--- /dev/null
+++ b/algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp
@@ -0,0 +1,163 @@
+// Source : https://leetcode.com/problems/count-of-range-sum/
+// Author : Hao Chen
+// Date   : 2016-01-15
+
+/*************************************************************************************** 
+ *
+ * Given an integer array nums, return the number of range sums that lie in [lower, 
+ * upper] inclusive.
+ * 
+ *     Range sum S(i, j) is defined as the sum of the elements in nums between indices 
+ * i and 
+ *     j (i ≤ j), inclusive.
+ * 
+ *     Note:
+ *     A naive algorithm of O(n2) is trivial. You MUST do better than that.
+ * 
+ *     Example:
+ *     Given nums = [-2, 5, -1], lower = -2, upper = 2,
+ *     Return 3.
+ *     The three ranges are : [0, 0], [2, 2], [0, 2] and their respective sums are: -2, -1, 2.
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ *               
+ ***************************************************************************************/
+
+
+/*
+ *  At first of all, we can do preprocess to calculate the prefix sums 
+ * 
+ *      S[i] = S(0, i), then S(i, j) = S[j] - S[i]. 
+ *  
+ *  Note: S(i, j) as the sum of range [i, j) where j exclusive and j > i. 
+ *
+ *  With these prefix sums, it is trivial to see that with O(n^2) time we can find all S(i, j) 
+ *  in the range [lower, upper]
+ *
+ *      int countRangeSum(vector<int>& nums, int lower, int upper) {
+ *        int n = nums.size();
+ *        long[] sums = new long[n + 1];
+ *        for (int i = 0; i < n; ++i) {
+ *            sums[i + 1] = sums[i] + nums[i];
+ *        }
+ *        int ans = 0;
+ *        for (int i = 0; i < n; ++i) {
+ *            for (int j = i + 1; j <= n; ++j) {
+ *                if (sums[j] - sums[i] >= lower && sums[j] - sums[i] <= upper) {
+ *                    ans++;
+ *                }
+ *            }
+ *        }
+ *        delete []sums;
+ *        return ans;
+ *      }
+ * 
+ *  The above solution would get time limit error.
+ *
+ *  Recall `count smaller number after self` where we encountered the problem
+ *
+ *      count[i] = count of nums[j] - nums[i] < 0 with j > i
+ *
+ *  Here, after we did the preprocess, we need to solve the problem
+ *
+ *      count[i] = count of a <= S[j] - S[i] <= b with j > i   
+ *
+ *  In other words, if we maintain the prefix sums sorted, and then are able to find out 
+ *  - how many of the sums are less than 'lower', say num1, 
+ *  - how many of the sums are less than 'upper + 1', say num2, 
+ *  Then 'num2 - num1' is the number of sums that lie within the range of [lower, upper].
+ *
+ */
+
+class Node{
+    public:
+        long long val;
+        int cnt; //amount of the nodes
+        Node *left, *right;
+        Node(long long v):val(v), cnt(1), left(NULL), right(NULL) {}
+};
+
+// a tree stores all of prefix sums
+class Tree{
+    public:
+        Tree():root(NULL){ }
+        ~Tree() { freeTree(root); }
+        
+        void Insert(long long val) {
+            Insert(root, val);
+        }
+        int LessThan(long long sum, int val) {
+            return LessThan(root, sum, val, 0);
+        }
+        
+    private:
+        Node* root;
+        
+        //general binary search tree insert algorithm
+        void Insert(Node* &root, long long val) {
+            if (!root) {
+                root = new Node(val);
+                return;
+            }
+            
+            root->cnt++;
+            
+            if (val < root->val ) {
+                Insert(root->left, val);
+            }else if (val > root->val) {
+                Insert(root->right, val);
+            }
+        }
+        //return how many of the sums less than `val`
+        //  -  `sum` is the new sums which hasn't been inserted
+        //  -  `val` is the `lower` or `upper+1`
+        int LessThan(Node* root, long long sum, int val, int res) {
+            
+            if (!root) return res;
+
+            if ( sum - root->val < val) {
+                //if (sum[j, i] < val), which means all of the right branch must be less than `val` 
+                //so we add the amounts of sums in right branch, and keep going the left branch.
+                res += (root->cnt - (root->left ? root->left->cnt : 0) );
+                return LessThan(root->left, sum, val, res);
+            }else if ( sum - root->val > val) {
+                //if (sum[j, i] > val), which means all of left brach must be greater than `val`
+                //so we just keep going the right branch.
+                return LessThan(root->right, sum, val, res);
+            }else {
+                //if (sum[j,i] == val), which means we find the correct place, 
+                //so we just return the the amounts of right branch.]
+                return res + (root->right ? root->right->cnt : 0);
+            }
+        }
+        void freeTree(Node* root){
+            if (!root) return;
+            if (root->left) freeTree(root->left);
+            if (root->right) freeTree(root->right);
+            delete root;
+        }
+        
+};
+
+
+
+class Solution {
+public:
+    int countRangeSum(vector<int>& nums, int lower, int upper) {
+        Tree tree;
+        tree.Insert(0);
+        long long sum = 0;
+        int res = 0;
+        
+        for (int n : nums) {
+            sum += n;
+            int lcnt = tree.LessThan(sum, lower);
+            int hcnt = tree.LessThan(sum, upper + 1);
+            res += (hcnt - lcnt);
+            tree.Insert(sum);
+        }
+
+        return res;
+    }
+};

From b40ca7942d9b2d1fd711b8e5cbd2b5e8007975d3 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Fri, 15 Jan 2016 22:42:31 +0800
Subject: [PATCH 16/54] New Problem "Count of Range Sum"

---
 README.md                                     |   1 +
 .../cpp/countOfRangeSum/CountOfRangeSum.cpp   | 163 ++++++++++++++++++
 2 files changed, 164 insertions(+)
 create mode 100644 algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp

diff --git a/README.md b/README.md
index cfee4ebf2..c4c976e14 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|327|[Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/) | [C++](./algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp)|Hard|
 |326|[Power of Three](https://leetcode.com/problems/power-of-three/) | [C++](./algorithms/cpp/powerOfThree/PowerOfThree.cpp)|Easy|
 |322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
diff --git a/algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp b/algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp
new file mode 100644
index 000000000..81b1f21bb
--- /dev/null
+++ b/algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp
@@ -0,0 +1,163 @@
+// Source : https://leetcode.com/problems/count-of-range-sum/
+// Author : Hao Chen
+// Date   : 2016-01-15
+
+/*************************************************************************************** 
+ *
+ * Given an integer array nums, return the number of range sums that lie in [lower, 
+ * upper] inclusive.
+ * 
+ *     Range sum S(i, j) is defined as the sum of the elements in nums between indices 
+ * i and 
+ *     j (i ≤ j), inclusive.
+ * 
+ *     Note:
+ *     A naive algorithm of O(n2) is trivial. You MUST do better than that.
+ * 
+ *     Example:
+ *     Given nums = [-2, 5, -1], lower = -2, upper = 2,
+ *     Return 3.
+ *     The three ranges are : [0, 0], [2, 2], [0, 2] and their respective sums are: -2, -1, 2.
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ *               
+ ***************************************************************************************/
+
+
+/*
+ *  At first of all, we can do preprocess to calculate the prefix sums 
+ * 
+ *      S[i] = S(0, i), then S(i, j) = S[j] - S[i]. 
+ *  
+ *  Note: S(i, j) as the sum of range [i, j) where j exclusive and j > i. 
+ *
+ *  With these prefix sums, it is trivial to see that with O(n^2) time we can find all S(i, j) 
+ *  in the range [lower, upper]
+ *
+ *      int countRangeSum(vector<int>& nums, int lower, int upper) {
+ *        int n = nums.size();
+ *        long[] sums = new long[n + 1];
+ *        for (int i = 0; i < n; ++i) {
+ *            sums[i + 1] = sums[i] + nums[i];
+ *        }
+ *        int ans = 0;
+ *        for (int i = 0; i < n; ++i) {
+ *            for (int j = i + 1; j <= n; ++j) {
+ *                if (sums[j] - sums[i] >= lower && sums[j] - sums[i] <= upper) {
+ *                    ans++;
+ *                }
+ *            }
+ *        }
+ *        delete []sums;
+ *        return ans;
+ *      }
+ * 
+ *  The above solution would get time limit error.
+ *
+ *  Recall `count smaller number after self` where we encountered the problem
+ *
+ *      count[i] = count of nums[j] - nums[i] < 0 with j > i
+ *
+ *  Here, after we did the preprocess, we need to solve the problem
+ *
+ *      count[i] = count of a <= S[j] - S[i] <= b with j > i   
+ *
+ *  In other words, if we maintain the prefix sums sorted, and then are able to find out 
+ *  - how many of the sums are less than 'lower', say num1, 
+ *  - how many of the sums are less than 'upper + 1', say num2, 
+ *  Then 'num2 - num1' is the number of sums that lie within the range of [lower, upper].
+ *
+ */
+
+class Node{
+    public:
+        long long val;
+        int cnt; //amount of the nodes
+        Node *left, *right;
+        Node(long long v):val(v), cnt(1), left(NULL), right(NULL) {}
+};
+
+// a tree stores all of prefix sums
+class Tree{
+    public:
+        Tree():root(NULL){ }
+        ~Tree() { freeTree(root); }
+        
+        void Insert(long long val) {
+            Insert(root, val);
+        }
+        int LessThan(long long sum, int val) {
+            return LessThan(root, sum, val, 0);
+        }
+        
+    private:
+        Node* root;
+        
+        //general binary search tree insert algorithm
+        void Insert(Node* &root, long long val) {
+            if (!root) {
+                root = new Node(val);
+                return;
+            }
+            
+            root->cnt++;
+            
+            if (val < root->val ) {
+                Insert(root->left, val);
+            }else if (val > root->val) {
+                Insert(root->right, val);
+            }
+        }
+        //return how many of the sums less than `val`
+        //  -  `sum` is the new sums which hasn't been inserted
+        //  -  `val` is the `lower` or `upper+1`
+        int LessThan(Node* root, long long sum, int val, int res) {
+            
+            if (!root) return res;
+
+            if ( sum - root->val < val) {
+                //if (sum[j, i] < val), which means all of the right branch must be less than `val` 
+                //so we add the amounts of sums in right branch, and keep going the left branch.
+                res += (root->cnt - (root->left ? root->left->cnt : 0) );
+                return LessThan(root->left, sum, val, res);
+            }else if ( sum - root->val > val) {
+                //if (sum[j, i] > val), which means all of left brach must be greater than `val`
+                //so we just keep going the right branch.
+                return LessThan(root->right, sum, val, res);
+            }else {
+                //if (sum[j,i] == val), which means we find the correct place, 
+                //so we just return the the amounts of right branch.]
+                return res + (root->right ? root->right->cnt : 0);
+            }
+        }
+        void freeTree(Node* root){
+            if (!root) return;
+            if (root->left) freeTree(root->left);
+            if (root->right) freeTree(root->right);
+            delete root;
+        }
+        
+};
+
+
+
+class Solution {
+public:
+    int countRangeSum(vector<int>& nums, int lower, int upper) {
+        Tree tree;
+        tree.Insert(0);
+        long long sum = 0;
+        int res = 0;
+        
+        for (int n : nums) {
+            sum += n;
+            int lcnt = tree.LessThan(sum, lower);
+            int hcnt = tree.LessThan(sum, upper + 1);
+            res += (hcnt - lcnt);
+            tree.Insert(sum);
+        }
+
+        return res;
+    }
+};

From eb58453db5801615133c36965e77bad0f803b302 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sat, 16 Jan 2016 21:02:16 +0800
Subject: [PATCH 17/54] filter out the blank line

---
 scripts/comments.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/comments.sh b/scripts/comments.sh
index 1d518fe24..69a6a10b6 100755
--- a/scripts/comments.sh
+++ b/scripts/comments.sh
@@ -160,14 +160,14 @@ fi
 # 2) the last two `sed` commands are used to add the comments tags
 case $FILE_EXT in
     .cpp )      xidel ${leetcode_url} -q -e "css('div.question-content')"  | \
-                    grep -v '                ' | sed '/^$/N;/^\n$/D'  | fold -w 85 -s |\
+                    grep -v '             ' | sed '/^$/N;/^\n$/D'  | fold -w 85 -s |\
                     sed 's/^/ * /' | sed '1i\'$'\n'"/*$(printf '%.0s*' {0..85}) "$'\n' |\
                     sed '2i\'$'\n''!@#$%'$'\n' | sed 's/!@#$%/ */' | \
                     sed '$a\'$'\n'"*$(printf '%.0s*' {0..85})*/"$'\n'| \
                     sed 's/^*/ /' > /tmp/tmp.txt
                 ;;
     .sh )      xidel ${leetcode_url} -q -e "css('div.question-content')"  | \
-                    grep -v '                ' |sed '/^$/N;/^\n$/D'  | fold -w 85 -s| \
+                    grep -v '             ' |sed '/^$/N;/^\n$/D'  | fold -w 85 -s| \
                     sed 's/^/# /' | sed '1i\'$'\n'"#$(printf '%.0s#' {0..85}) "$'\n' | \
                     sed '2i\'$'\n''#'$'\n' | sed '$a\'$'\n'"#$(printf '%.0s#' {0..85})"$'\n'\
                     > /tmp/tmp.txt

From e3b71eed8590fe9d1571d25f1cad00a34a60ea9a Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sat, 16 Jan 2016 21:04:17 +0800
Subject: [PATCH 18/54] New Problem "Expression Add Operators"

---
 .../ExpressionAddOperators.cpp                | 81 +++++++++++++++++++
 1 file changed, 81 insertions(+)
 create mode 100644 algorithms/cpp/expressionAddOperators/ExpressionAddOperators.cpp

diff --git a/algorithms/cpp/expressionAddOperators/ExpressionAddOperators.cpp b/algorithms/cpp/expressionAddOperators/ExpressionAddOperators.cpp
new file mode 100644
index 000000000..573d4fd26
--- /dev/null
+++ b/algorithms/cpp/expressionAddOperators/ExpressionAddOperators.cpp
@@ -0,0 +1,81 @@
+// Source : https://leetcode.com/problems/expression-add-operators/
+// Author : Hao Chen
+// Date   : 2016-01-16
+
+/*************************************************************************************** 
+ *
+ * Given a string that contains only digits 0-9 and a target value, return all 
+ * possibilities to add binary operators (not unary) +, -, or * between the digits so 
+ * they evaluate to the target value.
+ * 
+ * Examples: 
+ * "123", 6 -> ["1+2+3", "1*2*3"] 
+ * "232", 8 -> ["2*3+2", "2+3*2"]
+ * "105", 5 -> ["1*0+5","10-5"]
+ * "00", 0 -> ["0+0", "0-0", "0*0"]
+ * "3456237490", 9191 -> []
+ * 
+ * Credits:Special thanks to @davidtan1890 for adding this problem and creating all 
+ * test cases.
+ ***************************************************************************************/
+
+
+class Solution {
+public:
+    vector<string> addOperators(string num, int target) {
+        vector<string> result;
+        if (num.size() == 0) return result;
+        helper(num, target, result, "", 0, 0, 0, ' ');
+        return result;        
+    }
+    
+    //DFS algorithm
+    void helper(const string &num, const int target, //`num` and `target` never change
+                vector<string>& result, // the array store all of the answers
+                string solution, //the current potential answer.
+                int idx, // the current index of `num` array
+                long long val, // the current value we calculated so far
+                long long prev, // the lastest value we used for calculation, which used for operation prioirty adjustment
+                char preop ) // the latest "+" or "-" operation, which used for operation prioirty adjustment 
+    {
+        
+        if (target == val && idx == num.size()){
+            result.push_back(solution);
+            return;
+        }
+        if (idx == num.size()) return;
+        
+        string n;
+        long long v=0;
+        for(int i=idx; i<num.size(); i++) {
+            //get rid of the number which start by "0"
+            //e.g.  "05" is not the case.
+            if (n=="0") return;
+            
+            n = n + num[i];
+            v = v*10 + num[i]-'0';
+            
+            if (solution.size()==0){ 
+                // the first time for initialization
+                helper(num, target, result, n, i+1, v, 0, ' ');
+            }else{
+                // '+' or '-' needn't to adjust the priority
+                helper(num, target, result, solution + '+' + n, i+1, val+v, v, '+');
+                helper(num, target, result, solution + '-' + n, i+1, val-v, v, '-');
+                
+                //if we meet multiply operation, we need adjust the calcualtion priority
+                // e.g. if the previous value is calculated by 2+3=5, 
+                //      then if we need to multipy 4, it is not 5*4, it is 2+3*4=2+12=24
+                //      we need be careful about multiply again, such as: 2+3*4*5
+                if (preop=='+') {
+                    helper(num, target, result, solution + '*' + n, i+1, (val-prev)+prev*v, prev*v, preop);
+                }else if (preop=='-'){
+                    helper(num, target, result, solution + '*' + n, i+1, (val+prev)-prev*v, prev*v, preop);
+                }else {
+                    helper(num, target, result, solution + '*' + n, i+1, val*v, v, '*');
+                }
+            }
+        }
+        
+    }
+};

From 9dc59faaad9b287629317d7c9e51adc8eca5d9d2 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sat, 16 Jan 2016 21:15:22 +0800
Subject: [PATCH 19/54] update readme

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index c4c976e14..6ed7a7ccc 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,7 @@ LeetCode
 |285|[Inorder Successor in BST](https://leetcode.com/problems/inorder-successor-in-bst/) &hearts; | [Java](./algorithms/java/src/inorderSuccessorInBST/inorderSuccessorInBST.java)|Medium|
 |284|[Peeking Iterator](https://leetcode.com/problems/peeking-iterator/)  | [C++](./algorithms/cpp/peekingIterator/PeekingIterator.cpp)|Medium|
 |283|[Move Zeroes](https://leetcode.com/problems/move-zeroes/)  | [C++](./algorithms/cpp/moveZeroes/moveZeroes.cpp)|Easy|
+|282|[Expression Add Operators](https://leetcode.com/problems/expression-add-operators/)  | [C++](./algorithms/cpp/expressionAddOperators/ExpressionAddOperators.cpp)|Hard|
 |279|[Perfect Squares](https://leetcode.com/problems/perfect-squares/) | [C++](./algorithms/cpp/perfectSquares/PerfectSquares.cpp)|Medium|
 |278|[First Bad Version](https://leetcode.com/problems/first-bad-version/)| [C++](./algorithms/cpp/firstBadVersion/FirstBadVersion.cpp), [Java](./algorithms/java/src/firstBadVersion/firstBadVersion.java)|Easy|
 |275|[H-Index II](https://leetcode.com/problems/h-index-ii/)| [C++](./algorithms/cpp/h-Index/h-Index.II.cpp)|Medium|

From 1ab20b068dac5d7eff3878ddaa01493719cd81d1 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sat, 16 Jan 2016 22:03:01 +0800
Subject: [PATCH 20/54] New Problem "Odd Even Linked List"

---
 README.md                                     |  1 +
 .../oddEvenLinkedList/OddEvenLinkedList.cpp   | 53 +++++++++++++++++++
 2 files changed, 54 insertions(+)
 create mode 100644 algorithms/cpp/oddEvenLinkedList/OddEvenLinkedList.cpp

diff --git a/README.md b/README.md
index 6ed7a7ccc..42d073936 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|328|[Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/) | [C++](./algorithms/cpp/oddEvenLinkedList/OddEvenLinkedList.cpp)|Easy|
 |327|[Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/) | [C++](./algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp)|Hard|
 |326|[Power of Three](https://leetcode.com/problems/power-of-three/) | [C++](./algorithms/cpp/powerOfThree/PowerOfThree.cpp)|Easy|
 |322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
diff --git a/algorithms/cpp/oddEvenLinkedList/OddEvenLinkedList.cpp b/algorithms/cpp/oddEvenLinkedList/OddEvenLinkedList.cpp
new file mode 100644
index 000000000..6a206978e
--- /dev/null
+++ b/algorithms/cpp/oddEvenLinkedList/OddEvenLinkedList.cpp
@@ -0,0 +1,53 @@
+// Source : https://leetcode.com/problems/odd-even-linked-list/
+// Author : Hao Chen
+// Date   : 2016-01-16
+
+/*************************************************************************************** 
+ *
+ * Given a singly linked list, group all odd nodes together followed by the even nodes. 
+ * Please note here we are talking about the node number and not the value in the nodes.
+ * 
+ * You should try to do it in place. The program should run in O(1) space complexity 
+ * and O(nodes) time complexity.
+ * 
+ * Example:
+ * Given 1->2->3->4->5->NULL,
+ * return 1->3->5->2->4->NULL.
+ * 
+ * Note:
+ * The relative order inside both the even and odd groups should remain as it was in 
+ * the input. 
+ * The first node is considered odd, the second node even and so on ...
+ * 
+ * Credits:Special thanks to @aadarshjajodia for adding this problem and creating all 
+ * test cases.
+ ***************************************************************************************/
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* oddEvenList(ListNode* head) {
+        if (!head) return head;
+        ListNode* pOdd = head;
+        ListNode* p = head->next;
+        ListNode* pNext = NULL;
+        while(p && (pNext=p->next)) {
+            
+            p->next = pNext->next;
+            pNext->next = pOdd->next;
+            pOdd->next = pNext;
+            
+            p = p->next;
+            pOdd = pOdd->next;
+        
+        }
+        return head;
+    }
+};

From 1c8023e53f27cc99b2df4360bd35a0647e490005 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sat, 16 Jan 2016 22:45:04 +0800
Subject: [PATCH 21/54] New Problem "Single Number III"

---
 README.md                                     |  1 +
 .../cpp/singleNumber/singleNumber.III.cpp     | 94 +++++++++++++++++++
 2 files changed, 95 insertions(+)
 create mode 100644 algorithms/cpp/singleNumber/singleNumber.III.cpp

diff --git a/README.md b/README.md
index 42d073936..3dfe34ef6 100644
--- a/README.md
+++ b/README.md
@@ -38,6 +38,7 @@ LeetCode
 |268|[Missing Number](https://leetcode.com/problems/missing-number/)| [C++](./algorithms/cpp/missingNumber/MissingNumber.cpp)|Medium|
 |264|[Ugly Number II](https://leetcode.com/problems/ugly-number-ii/)| [C++](./algorithms/cpp/uglyNumber/UglyNumber.II.cpp)|Medium|
 |263|[Ugly Number](https://leetcode.com/problems/ugly-number/)| [C++](./algorithms/cpp/uglyNumber/UglyNumber.cpp)|Easy|
+|260|[Single Number III](https://leetcode.com/problems/single-number-iii/)| [C++](./argorithms/cpp/singleNumber/singleNumber.III.cpp)|Medium|
 |258|[Add Digits](https://leetcode.com/problems/add-digits/)| [C++](./algorithms/cpp/addDigits/addDigits.cpp)|Easy|
 |257|[Binary Tree Paths](https://leetcode.com/problems/binary-tree-paths/)| [C++](./algorithms/cpp/binaryTreePaths/binaryTreePaths.cpp)|Easy|
 |242|[Valid Anagram](https://leetcode.com/problems/valid-anagram/)| [C++](./algorithms/cpp/anagrams/ValidAnagram.cpp)|Easy|
diff --git a/algorithms/cpp/singleNumber/singleNumber.III.cpp b/algorithms/cpp/singleNumber/singleNumber.III.cpp
new file mode 100644
index 000000000..d2f86bd52
--- /dev/null
+++ b/algorithms/cpp/singleNumber/singleNumber.III.cpp
@@ -0,0 +1,94 @@
+// Source : https://leetcode.com/problems/single-number-iii/
+// Author : Hao Chen
+// Date   : 2016-01-16
+
+/*************************************************************************************** 
+ *
+ * Given an array of numbers nums, in which exactly two elements appear only once and 
+ * all the other elements appear exactly twice. Find the two elements that appear only 
+ * once.
+ * 
+ * For example:
+ * 
+ * Given nums = [1, 2, 1, 3, 2, 5], return [3, 5].
+ * 
+ * Note:
+ * 
+ * The order of the result is not important. So in the above example, [5, 3] is also 
+ * correct.
+ * Your algorithm should run in linear runtime complexity. Could you implement it using 
+ * only constant space complexity?
+ * 
+ * Credits:Special thanks to @jianchao.li.fighter for adding this problem and creating 
+ * all test cases.
+ ***************************************************************************************/
+
+
+/*
+ * For the problem - only one number appears once when all other numbers appears exactly twice.
+ * 
+ * We know, we can XOR all of the array elements. Since X^X is zero, and X^0 is X, 
+ * so all of the duplicated number will zero themselves out, and the only number would be the result.
+ * 
+ * However, this solution cannot be applied directly to finding two numbers that appear once each. 
+ * 
+ * Suppose that these numbers that appear once are X and Y, and all other numbers appear twice. 
+ * If we decide to XOR all the array's elements, the overall result would actually be `X^Y`. 
+ * 
+ * Unfortunately, there is no way to extract J and K out of their XOR. 
+ * 
+ * But since X and Y are different, we are sure that X^Y is different than zero. 
+ * 
+ * This information is valuable in sense that we know pieces of information that differ.
+ * If we pick up any bit that is 1 in X XOR Y, we can use it as a mask to test each element of the array. 
+ * 
+ * Obviously, that mask will be the discriminator between X and Y - 
+ * 
+ *    Only one of them will have value 1 at that particular position.
+ *         
+ *         
+ * Now that we have the mask with exactly one bit set to 1, we can walk through the array once again. 
+ * 
+ * But this time we are going to maintain two XORed results. 
+ * 
+ *   - One for numbers that have bit 1 at the mask's position 
+ *   - Another for numbers that have bit 0 at that position
+ *   
+ * In this way, we are sure that all duplicates will go into the same pile. 
+ * 
+ * But likewise, we are sure that X and Y will go into separate piles. 
+ * 
+ * So, the overall result is that 
+ *  - the first XORed result will be equal to X 
+ *  - and the second XORed result will be equal to Y
+ *  
+*/
+
+class Solution {
+public:
+    vector<int> singleNumber(vector<int>& nums) {
+        int allxor = 0;
+        for (int n : nums) {
+            allxor ^= n;
+        }
+        int mask = 1;
+        while ( (mask & allxor) == 0 ) {
+            mask <<= 1;
+        }
+
+        int zero = 0;
+        int one = 0;
+        for (int n : nums) {
+            if (n & mask ){
+                one ^= n;
+            }else {
+                zero ^= n;
+            }
+        }
+        
+        vector<int> result;
+        result.push_back(zero);
+        result.push_back(one);
+        return result;
+    }
+};

From 0d9585f087581fe693abe7075764ebc372e3382c Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sat, 16 Jan 2016 22:46:37 +0800
Subject: [PATCH 22/54] link error

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 3dfe34ef6..aa2f240c2 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ LeetCode
 |268|[Missing Number](https://leetcode.com/problems/missing-number/)| [C++](./algorithms/cpp/missingNumber/MissingNumber.cpp)|Medium|
 |264|[Ugly Number II](https://leetcode.com/problems/ugly-number-ii/)| [C++](./algorithms/cpp/uglyNumber/UglyNumber.II.cpp)|Medium|
 |263|[Ugly Number](https://leetcode.com/problems/ugly-number/)| [C++](./algorithms/cpp/uglyNumber/UglyNumber.cpp)|Easy|
-|260|[Single Number III](https://leetcode.com/problems/single-number-iii/)| [C++](./argorithms/cpp/singleNumber/singleNumber.III.cpp)|Medium|
+|260|[Single Number III](https://leetcode.com/problems/single-number-iii/)| [C++](./algorithms/cpp/singleNumber/singleNumber.III.cpp)|Medium|
 |258|[Add Digits](https://leetcode.com/problems/add-digits/)| [C++](./algorithms/cpp/addDigits/addDigits.cpp)|Easy|
 |257|[Binary Tree Paths](https://leetcode.com/problems/binary-tree-paths/)| [C++](./algorithms/cpp/binaryTreePaths/binaryTreePaths.cpp)|Easy|
 |242|[Valid Anagram](https://leetcode.com/problems/valid-anagram/)| [C++](./algorithms/cpp/anagrams/ValidAnagram.cpp)|Easy|

From 1f24b4a199f7cae2a9f46d0b915f72d1b0ef28b5 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sun, 17 Jan 2016 16:12:12 +0800
Subject: [PATCH 23/54] New Problem "Burst Balloons"

---
 README.md                                     |   1 +
 .../cpp/burstBalloons/BurstBalloons.cpp       | 104 ++++++++++++++++++
 2 files changed, 105 insertions(+)
 create mode 100644 algorithms/cpp/burstBalloons/BurstBalloons.cpp

diff --git a/README.md b/README.md
index aa2f240c2..6a9945f68 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,7 @@ LeetCode
 |322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
+|312|[Burst Balloons](https://leetcode.com/problems/burst-balloons/) | [C++](./algorithms/cpp/burstBalloons/BurstBalloons.cpp)|Hard|
 |307|[Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/) | [C++](./algorithms/cpp/rangeSumQuery-Immutable/rangeSumQuery-Mutable/RangeSumQueryMutable.cpp)|Medium|
 |306|[Additive Number](https://leetcode.com/problems/additive-number/) | [C++](./algorithms/cpp/additiveNumber/AdditiveNumber.cpp)|Medium|
 |304|[Range Sum Query 2D - Immutable](https://leetcode.com/problems/range-sum-query-2d-immutable/) | [C++](./algorithms/cpp/rangeSumQuery2D-Immutable/RangeSumQuery2dImmutable.cpp)|Medium|
diff --git a/algorithms/cpp/burstBalloons/BurstBalloons.cpp b/algorithms/cpp/burstBalloons/BurstBalloons.cpp
new file mode 100644
index 000000000..901f2e8eb
--- /dev/null
+++ b/algorithms/cpp/burstBalloons/BurstBalloons.cpp
@@ -0,0 +1,104 @@
+// Source : https://leetcode.com/problems/burst-balloons/
+// Author : Hao Chen
+// Date   : 2016-01-17
+
+/*************************************************************************************** 
+ *
+ * Given n balloons, indexed from 0 to n-1. Each balloon is painted with a
+ *     number on it represented by array nums.
+ * 
+ *     You are asked to burst all the balloons. If the you burst
+ *     balloon i you will get nums[left] * nums[i] * nums[right] coins. Here left
+ *     and right are adjacent indices of i. After the burst, the left and right
+ *     then becomes adjacent.
+ * 
+ *     Find the maximum coins you can collect by bursting the balloons wisely.
+ * 
+ *     Note: 
+ *     (1) You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can 
+ * not burst them.
+ *     (2) 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100
+ * 
+ *     Example:
+ * 
+ *     Given [3, 1, 5, 8]
+ * 
+ *     Return 167
+ * 
+ *     nums = [3,1,5,8] --> [3,5,8] -->   [3,8]   -->  [8]  --> []
+ *    coins =  3*1*5      +  3*5*8    +  1*3*8      + 1*8*1   = 167
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ ***************************************************************************************/
+
+
+
+class Solution {
+public:
+    int maxCoins(vector<int>& nums) {
+        //remove all of zero item
+        nums.erase(remove_if(nums.begin(), nums.end(), [](int n){return n==0;}), nums.end());
+        
+        //add 1 for head and tail
+        nums.insert(nums.begin(),1);
+        nums.push_back(1);
+        
+        int n = nums.size();
+        vector< vector<int> > matrix(n, vector<int>(n,0));
+        
+        return maxCoins_DP(nums, matrix);
+        return maxCoins_DC(nums, matrix, 0, n-1);
+    }
+    
+    
+    //Divide and Conquer
+    //
+    //  If we seprate the array to two part, left part and right part.
+    //
+    //  Then, we will find in this problem the left and right become adjacent 
+    //  and have effects on the maxCoins in the future.
+    //
+    //  So, if we think reversely, if the balloon i is the last balloon of all to burst, 
+    //  the left and right section now has well defined boundary and do not affect each other! 
+    //  Therefore we can do either recursive method with memoization
+    //
+    int maxCoins_DC(vector<int>& nums, vector<vector<int>>& matrix, int low, int high) {
+        if (low + 1 == high) return 0;
+        if (matrix[low][high] > 0) return matrix[low][high];
+        int result = 0;
+        for (int i = low + 1; i < high; ++i){
+            result = max(result,  nums[low] * nums[i] * nums[high] 
+                                    + maxCoins_DC(nums, matrix, low, i) 
+                                    + maxCoins_DC(nums, matrix, i, high));
+        }
+        matrix[low][high] = result;
+        return result;
+    }
+    
+    //Dynamic Programming
+    // 
+    //  using the same idea of above 
+    //
+    int maxCoins_DP(vector<int>& nums, vector<vector<int>>& dp) {
+        int n = nums.size();
+        for (int k = 2; k < n; ++k) {
+            for (int low = 0; low < n - k; low++){
+                int high = low + k;
+                for (int i = low + 1; i < high; ++i)
+                    dp[low][high] = max( dp[low][high],
+                         nums[low] * nums[i] * nums[high] + dp[low][i] + dp[i][high]);
+            }
+        }
+        return dp[0][n - 1];
+    }
+    
+private:
+    void printVector(vector<int>& nums) {
+        cout << "nums: ";
+        for (auto n: nums) {
+            cout << n << ' ';
+        }
+        cout << '\n';
+    }
+};

From 53fe7c9cac47b32b6ee11b6d90193738f100cd45 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Thu, 21 Jan 2016 15:13:39 +0800
Subject: [PATCH 24/54] New Problem "Create Maximum Number"

---
 README.md                                     |   1 +
 .../CreateMaximumNumber.cpp                   | 152 ++++++++++++++++++
 2 files changed, 153 insertions(+)
 create mode 100644 algorithms/cpp/createMaximumNumber/CreateMaximumNumber.cpp

diff --git a/README.md b/README.md
index 6a9945f68..6d154e63c 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,7 @@ LeetCode
 |327|[Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/) | [C++](./algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp)|Hard|
 |326|[Power of Three](https://leetcode.com/problems/power-of-three/) | [C++](./algorithms/cpp/powerOfThree/PowerOfThree.cpp)|Easy|
 |322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
+|321|[Create Maximum Number](https://leetcode.com/problems/create-maximum-number/) | [C++](./algorithms/cpp/createMaximumNumber/CreateMaximumNumber.cpp)|Hard|
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
 |312|[Burst Balloons](https://leetcode.com/problems/burst-balloons/) | [C++](./algorithms/cpp/burstBalloons/BurstBalloons.cpp)|Hard|
diff --git a/algorithms/cpp/createMaximumNumber/CreateMaximumNumber.cpp b/algorithms/cpp/createMaximumNumber/CreateMaximumNumber.cpp
new file mode 100644
index 000000000..dc88f9a41
--- /dev/null
+++ b/algorithms/cpp/createMaximumNumber/CreateMaximumNumber.cpp
@@ -0,0 +1,152 @@
+// Source : https://leetcode.com/problems/create-maximum-number/
+// Author : Hao Chen
+// Date   : 2016-01-21
+
+/*************************************************************************************** 
+ *
+ * Given two arrays of length m and n with digits 0-9 representing two numbers.
+ *     Create the maximum number of length k  from digits of the two. The relative 
+ * order of the digits
+ *     from the same array must be preserved. Return an array of the k digits. You 
+ * should try to optimize your time and space complexity.
+ * 
+ *     Example 1:
+ * 
+ *     nums1 = [3, 4, 6, 5]
+ *     nums2 = [9, 1, 2, 5, 8, 3]
+ *     k = 5
+ *     return [9, 8, 6, 5, 3]
+ * 
+ *     Example 2:
+ * 
+ *     nums1 = [6, 7]
+ *     nums2 = [6, 0, 4]
+ *     k = 5
+ *     return [6, 7, 6, 0, 4]
+ * 
+ *     Example 3:
+ * 
+ *     nums1 = [3, 9]
+ *     nums2 = [8, 9]
+ *     k = 3
+ *     return [9, 8, 9]
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ ***************************************************************************************/
+
+
+
+/*
+ * Solution
+ * --------
+ * 
+ * 1) We split the `K` to two parts : `i` & `k-i`  0<= i <= k
+ * 
+ * 2) Find the max number for both arrays with giving the length `i` and `k-i`
+ *      - sub1 = FindMaxNumber(num1, len=i);
+ *      - sub2 = FindMaxNumber(num2, len=k-i);
+ *    Here, we need use stack-way to solve find the max number.
+ * 
+ * 3) Merge two arrays 
+ *      - solution = Merge(sub1, sub2);
+ *    Here, we need be careful if a two number are same which one we need to take.  For examples: 
+ *      [6,7]
+ *      [6,0,4]
+ *      5
+ *      
+ *      [2,5,6,4,4,0]
+ *      [7,3,8,0,6,5,7,6,2]
+ *      15
+ * 
+ * 4) compare with the last solution
+ *     - result = max(result, solution); 
+ * 
+ * 
+ */
+
+
+class Solution {
+public:
+    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
+        vector<int> result;
+        int len1 = nums1.size();
+        int len2 = nums2.size();
+        for (int i=0; i<=k; i++){
+            if (len1 < i || len2 < k-i) continue;
+            vector<int> sub1 = findMaxSubArray(nums1, i);
+            vector<int> sub2 = findMaxSubArray(nums2, k-i);
+            vector<int> merge = mergeTwoArrays(sub1, sub2);
+            if (compareTwoArray(merge, 0, result, 0)) {
+                result = merge;
+            }
+        }
+        return result;
+    }
+    
+    
+    bool compareTwoArray(vector<int>& nums1, int start1, vector<int>& nums2, int start2) {
+        int n1 = nums1.size();
+        int n2 = nums2.size();
+        for(; start1<n1 && start2<n2; start1++, start2++){
+            if (nums1[start1] > nums2[start2]) return true;
+            if (nums1[start1] < nums2[start2]) return false;
+        }
+        //if num1 still have numbers, return true, else return false
+        return start1 < nums1.size();
+    }
+    
+    vector<int> mergeTwoArrays(vector<int>& nums1, vector<int>& nums2) {
+        vector<int> result;
+        int len1 = nums1.size();
+        int len2 = nums2.size();
+        int pos1=0, pos2=0;
+        while ( pos1 < len1 && pos2 < len2 ){
+            // Be careful if two numbers are equal. consider the following case
+            // case 1: [6,7], [6,0,4]  - we have same item - 6
+            // case 2: [4,0,2], [2,0,3,1] - we have same item - 0
+            // which one we need to merge?
+            // We need compare the rest of array.
+            if (nums1[pos1] == nums2[pos2]){
+                result.push_back( compareTwoArray(nums1, pos1+1, nums2, pos2+1) ? 
+                                    nums1[pos1++] : nums2[pos2++]);
+            }else {
+                result.push_back(nums1[pos1] > nums2[pos2] ? 
+                                    nums1[pos1++] : nums2[pos2++]);
+            }
+        }
+        
+        if (pos1 < len1){
+            result.insert(result.end(), nums1.begin()+pos1, nums1.end());
+        }
+        if (pos2 < len2) {
+            result.insert(result.end(), nums2.begin()+pos2, nums2.end());
+        }
+        
+        return result;
+    }
+    
+    
+    // using a stack method to find the max sub-array
+    // k <= nums.size()
+    vector<int> findMaxSubArray(vector<int>& nums, int k) {
+        int len = nums.size();
+        if ( k >= len ) return nums;
+        vector<int> result(k, 0);
+        int idx = 0; // the postion for result array
+        for (int i=0; i<len; i++){
+            // if we met a number > the last element of result[], 
+            // and we still have enough numbers,
+            // then pop up the item
+            while (idx>0 && k - idx < len - i && result[idx-1] < nums[i]) {
+                idx--;
+            }
+            //push the number into the result[]
+            if (idx < k) {
+                result[idx++] = nums[i];
+            }
+        }
+        return result;
+    }
+    
+};

From 69a1d4b8240ccb64bd456ec26d3452c7cd71669a Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Thu, 21 Jan 2016 23:44:42 +0800
Subject: [PATCH 25/54] New Problem "Longest Increasing Path in a Matrix"

---
 README.md                                     |  1 +
 .../LongestIncreasingPathInAMatrix.cpp        | 81 +++++++++++++++++++
 2 files changed, 82 insertions(+)
 create mode 100644 algorithms/cpp/longestIncreasingPathInAMatrix/LongestIncreasingPathInAMatrix.cpp

diff --git a/README.md b/README.md
index 6d154e63c..8762d1e84 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|329|[Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/) | [C++](./algorithms/cpp/longestIncreasingPathInAMatrix/LongestIncreasingPathInAMatrix.cpp)|Medium|
 |328|[Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/) | [C++](./algorithms/cpp/oddEvenLinkedList/OddEvenLinkedList.cpp)|Easy|
 |327|[Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/) | [C++](./algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp)|Hard|
 |326|[Power of Three](https://leetcode.com/problems/power-of-three/) | [C++](./algorithms/cpp/powerOfThree/PowerOfThree.cpp)|Easy|
diff --git a/algorithms/cpp/longestIncreasingPathInAMatrix/LongestIncreasingPathInAMatrix.cpp b/algorithms/cpp/longestIncreasingPathInAMatrix/LongestIncreasingPathInAMatrix.cpp
new file mode 100644
index 000000000..a7e6a4423
--- /dev/null
+++ b/algorithms/cpp/longestIncreasingPathInAMatrix/LongestIncreasingPathInAMatrix.cpp
@@ -0,0 +1,81 @@
+// Source : https://leetcode.com/problems/longest-increasing-path-in-a-matrix/
+// Author : Hao Chen
+// Date   : 2016-01-21
+
+/*************************************************************************************** 
+ *
+ * Given an integer matrix, find the length of the longest increasing path.
+ * 
+ * From each cell, you can either move to four directions: left, right, up or down. You 
+ * may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not 
+ * allowed).
+ * 
+ * Example 1:
+ * 
+ * nums = [
+ *   [>9, 9, 4],
+ *   [>6, 6, 8],
+ *   [>2,>1, 1]
+ * ]
+ * 
+ * Return 4
+ * 
+ * The longest increasing path is [1, 2, 6, 9].
+ * 
+ * Example 2:
+ * 
+ * nums = [
+ *   [>3,>4,>5],
+ *   [ 3, 2,>6],
+ *   [ 2, 2, 1]
+ * ]
+ * 
+ * Return 4
+ * 
+ * The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ ***************************************************************************************/
+
+
+class Solution {
+public:
+    int longestIncreasingPath(vector<vector<int>>& matrix) {
+        int result = 0;
+        int row = matrix.size();
+        int col = row ? matrix[0].size() : 0;
+        vector<vector<int>> path = vector<vector<int>>(row, vector<int>(col, 0));
+        for (int r = 0; r < row; r++) {
+            for (int c = 0; c < col; c++) {
+                result = max(result, helper(matrix, path, row, col, r, c));
+            }
+        }
+        return result;
+    }
+    
+    int helper(vector<vector<int>>& matrix, vector<vector<int>>& path, const int row, const int col, int r, int c) {
+
+        if (path[r][c]>0) return path[r][c];
+        
+        int maxPath = 0;
+        
+        int tmp = matrix[r][c]; 
+        matrix[r][c]=INT_MIN;  
+        if (r < row-1 && tmp < matrix[r+1][c]) {
+            maxPath = max(maxPath, helper(matrix, path, row, col, r+1, c));
+        }
+        if (c < col-1 && tmp < matrix[r][c+1]) {
+            maxPath = max(maxPath, helper(matrix, path, row, col, r, c+1));
+        }
+        if (r > 0 && tmp < matrix[r-1][c]) {
+            maxPath = max(maxPath, helper(matrix, path, row, col, r-1, c));
+        }
+        if (c > 0 && tmp < matrix[r][c-1]) {
+            maxPath = max(maxPath, helper(matrix, path, row, col, r, c-1));
+        }
+        matrix[r][c] = tmp;
+        path[r][c] = maxPath + 1;
+        return path[r][c];
+    }
+};

From 50b9b4ee87d1f0c4cba69c428a7f4ff81d550c19 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sun, 24 Jan 2016 15:27:08 +0800
Subject: [PATCH 26/54] New Problem "Minimum Height Trees"

---
 README.md                                     |  1 +
 .../minimumHeightTrees/MinimumHeightTrees.cpp | 98 +++++++++++++++++++
 2 files changed, 99 insertions(+)
 create mode 100644 algorithms/cpp/minimumHeightTrees/MinimumHeightTrees.cpp

diff --git a/README.md b/README.md
index 8762d1e84..6d410f75a 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,7 @@ LeetCode
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
 |312|[Burst Balloons](https://leetcode.com/problems/burst-balloons/) | [C++](./algorithms/cpp/burstBalloons/BurstBalloons.cpp)|Hard|
+|310|[Minimum Height Trees](https://leetcode.com/problems/minimum-height-trees/) | [C++](./algorithms/cpp/minimumHeightTrees/MinimumHeightTrees.cpp)|Medium|
 |307|[Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/) | [C++](./algorithms/cpp/rangeSumQuery-Immutable/rangeSumQuery-Mutable/RangeSumQueryMutable.cpp)|Medium|
 |306|[Additive Number](https://leetcode.com/problems/additive-number/) | [C++](./algorithms/cpp/additiveNumber/AdditiveNumber.cpp)|Medium|
 |304|[Range Sum Query 2D - Immutable](https://leetcode.com/problems/range-sum-query-2d-immutable/) | [C++](./algorithms/cpp/rangeSumQuery2D-Immutable/RangeSumQuery2dImmutable.cpp)|Medium|
diff --git a/algorithms/cpp/minimumHeightTrees/MinimumHeightTrees.cpp b/algorithms/cpp/minimumHeightTrees/MinimumHeightTrees.cpp
new file mode 100644
index 000000000..9f3a125f2
--- /dev/null
+++ b/algorithms/cpp/minimumHeightTrees/MinimumHeightTrees.cpp
@@ -0,0 +1,98 @@
+// Source : https://leetcode.com/problems/minimum-height-trees/
+// Author : Hao Chen
+// Date   : 2016-01-24
+
+/*************************************************************************************** 
+ *
+ * For a undirected graph with tree characteristics, we can choose any node as the 
+ * root. The result graph is then a rooted tree. Among all possible rooted trees, those 
+ * with minimum height are called minimum height trees (MHTs).
+ *
+ * Given such a graph, write a function to find all the MHTs and return a list of 
+ * their root labels.
+ * 
+ *     *Format*
+ *     The graph contains n nodes which are labeled from 0 to n - 1.
+ *     You will be given the number n and a list of undirected edges (each edge is a 
+ *     pair of labels).
+ * 
+ *  
+ *     You can assume that no duplicate edges will appear in edges. Since all edges are
+ *     undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.
+ * 
+ *     Example 1:
+ * 
+ *     Given n = 4, edges = [[1, 0], [1, 2], [1, 3]]
+ * 
+ *         0
+ *         |
+ *         1
+ *        / \
+ *       2   3
+ * 
+ *     return  [1]
+ * 
+ *     Example 2:
+ * 
+ *     Given n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]
+ * 
+ *      0  1  2
+ *       \ | /
+ *         3
+ *         |
+ *         4
+ *         |
+ *         5
+ * 
+ *     return  [3, 4]
+ * 
+ *     How many MHTs can a graph have at most?
+ * 
+ *     Note:
+ * 
+ *     (1) According to the definition of tree on Wikipedia: https://en.wikipedia.org/wiki/Tree_(graph_theory)
+ *         “a tree is an undirected graph in which any two vertices are connected by exactly one path. 
+ *         In other words, any connected graph without simple cycles is a tree.”
+ * 
+ *     (2) The height of a rooted tree is the number of edges on the longest downward path between 
+ *         the root and a leaf.
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ ***************************************************************************************/
+
+class Solution {
+public:
+    vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {
+        //corner case
+        if ( n <= 1 ) return {0};
+        
+        //construct a edges search data stucture
+        vector<unordered_set<int>> graph(n);
+        for (auto e : edges) {
+            graph[e.first].insert(e.second);
+            graph[e.second].insert(e.first);
+        }
+        
+        //find all of leaf nodes
+        vector<int> current;
+        for (int i=0; i<graph.size(); i++){
+            if (graph[i].size() == 1)  current.push_back(i);
+        }
+        
+        // BFS the graph
+        while (true) {
+            vector<int> next;
+            for (int node : current) {
+                for (int neighbor : graph[node]) {
+                    graph[neighbor].erase(node);
+                    if (graph[neighbor].size() == 1) next.push_back(neighbor);
+                }
+            }
+            if (next.empty()) break;
+            current = next;
+        }
+        return current;
+    }
+    
+};

From e594f51689888f6b8d836b5631ec39997c80b3e1 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Mon, 25 Jan 2016 14:53:39 +0800
Subject: [PATCH 27/54] another solution for "Bulb Switcher"

---
 algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp | 38 +++++++++++++++++++-
 1 file changed, 37 insertions(+), 1 deletion(-)

diff --git a/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp b/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp
index 04b046391..d4f51736b 100644
--- a/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp
+++ b/algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp
@@ -1,5 +1,5 @@
 // Source : https://leetcode.com/problems/bulb-switcher/
-// Author : Calinescu Valentin
+// Author : Calinescu Valentin, Hao Chen
 // Date   : 2015-12-28
 
 /*************************************************************************************** 
@@ -21,6 +21,42 @@
  * So you should return 1, because there is only one bulb is on.
  * 
  ***************************************************************************************/
+
+ /* Solution
+  * --------
+  *
+  * We know, 
+  *   - if a bulb can be switched to ON eventually, it must be switched by ODD times
+  *   - Otherwise, if a bulb has been switched by EVEN times, it will be OFF eventually.
+  * So, 
+  *   - If bulb `i` ends up ON if and only if `i` has an ODD numbers of divisors.
+  * And we know, 
+  *   - the divisors come in pairs. for example: 
+  *     12 - [1,12] [2,6] [3,4] [6,2] [12,1] (the 12th bulb would be switched by 1,2,3,4,6,12)
+  *   - the pairs means almost all of the numbers are switched by EVEN times.
+  *
+  * But we have a special case - square numbers
+  *   - A square number must have a divisors pair with same number. such as 4 - [2,2], 9 - [3,3]
+  *   - So, a square number has a ODD numbers of divisors.
+  *
+  * At last, we figure out the solution is: 
+  *    
+  *    Count the number of the squre numbers!! 
+  */
+
+class Solution {
+public:
+    int bulbSwitch(int n) {
+        int cnt = 0;
+        for (int i=1; i*i<=n; i++) { 
+            cnt++;
+        }
+        return cnt;
+    }
+};
+
+
+
  /* 
  * Solution 1 - O(1)
  * =========

From 8469352740f8b23e0d1234af8d88d75ba0a81ebf Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Tue, 26 Jan 2016 23:25:41 +0800
Subject: [PATCH 28/54] another implementation for "Coin Change"

---
 algorithms/cpp/coinChange/coinChange.cpp | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/algorithms/cpp/coinChange/coinChange.cpp b/algorithms/cpp/coinChange/coinChange.cpp
index e8ddc9c51..2b7d9b296 100644
--- a/algorithms/cpp/coinChange/coinChange.cpp
+++ b/algorithms/cpp/coinChange/coinChange.cpp
@@ -1,5 +1,5 @@
 // Source : https://leetcode.com/problems/coin-change/
-// Author : Calinescu Valentin
+// Author : Calinescu Valentin, Hao Chen
 // Date   : 2015-12-28
 
 /*************************************************************************************** 
@@ -60,3 +60,24 @@ class Solution {
             return -1;
     }
 };
+
+
+//Another DP implmentation, same idea above 
+class Solution {
+public:
+    int coinChange(vector<int>& coins, int amount) {
+        const int MAX = amount +1;
+        vector<int> dp(amount+1, MAX);
+        dp[0]=0;
+        
+        for(int i=1; i<=amount; i++) {
+            for (int j=0; j<coins.size(); j++){
+                if (i >= coins[j]) {
+                    dp[i] = min( dp[i], dp[i-coins[j]] + 1 );
+                }
+            }
+        }
+
+        return dp[amount]==MAX ? -1 : dp[amount];
+    }
+};

From 79a570c0f246b067f54bccc881420daf2ff4d863 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Wed, 27 Jan 2016 00:07:13 +0800
Subject: [PATCH 29/54] another solution for "Longest Increasing Subsequence"

---
 .../longestIncreasingSubsequence.cpp          | 26 ++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/algorithms/cpp/longestIncreasingSubsequence/longestIncreasingSubsequence.cpp b/algorithms/cpp/longestIncreasingSubsequence/longestIncreasingSubsequence.cpp
index 70a7fadab..30c65e9f4 100644
--- a/algorithms/cpp/longestIncreasingSubsequence/longestIncreasingSubsequence.cpp
+++ b/algorithms/cpp/longestIncreasingSubsequence/longestIncreasingSubsequence.cpp
@@ -1,5 +1,5 @@
 // Source : https://leetcode.com/problems/longest-increasing-subsequence/
-// Author : Calinescu Valentin
+// Author : Calinescu Valentin, Hao Chen
 // Date   : 2015-11-06
 
 /*************************************************************************************** 
@@ -22,6 +22,30 @@
  *               
  ***************************************************************************************/
 
+
+
+// O(n^2) - dynamic programming
+class Solution {
+public:
+    int lengthOfLIS(vector<int>& nums) {
+        
+        int len = nums.size();
+        int maxLen = 0;
+        vector<int> dp(len, 1);
+        
+        for (int i=0; i<len; i++) {
+            for(int j=0; j<i; j++) {
+                if ( nums[j] < nums[i] ) {
+                    dp[i] = max(dp[i], dp[j] + 1);
+                }
+            }
+            maxLen = max(maxLen, dp[i]);
+        }
+        return maxLen;
+    }
+};
+
+
 class Solution {
 public:
     

From 286583a8f80354990703eb783b2c36455b7a616d Mon Sep 17 00:00:00 2001
From: wilsoncao <275239608@qq.com>
Date: Sat, 13 Feb 2016 19:31:53 -0500
Subject: [PATCH 30/54] update

---
 .DS_Store                                       | Bin 0 -> 8196 bytes
 algorithms/.DS_Store                            | Bin 0 -> 10244 bytes
 algorithms/cpp/.DS_Store                        | Bin 0 -> 22532 bytes
 algorithms/cpp/majorityElement/.DS_Store        | Bin 0 -> 6148 bytes
 .../cpp/majorityElement/majorityElement.II.cpp  |   2 +-
 5 files changed, 1 insertion(+), 1 deletion(-)
 create mode 100644 .DS_Store
 create mode 100644 algorithms/.DS_Store
 create mode 100644 algorithms/cpp/.DS_Store
 create mode 100644 algorithms/cpp/majorityElement/.DS_Store

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..a88d1f977020681eb1ce37775d2046438f4c31e7
GIT binary patch
literal 8196
zcmeI1T}&KR6vxj2TIRAs?-ppcrP4JhQh^FpC?&OBmXEeUQc^yaFI{JMrZ91s!JXL!
zB_wE~QR7FnF(y8k2x^VS2Oso7AB-_pV_!5jMvVI6n@=X{L*G1i?ku6e`ec-(bCbE}
z-gEDnx$~dj%+1*a0E}m~R)7cqD0B$RLsV^3#JD)Nlp^0#LKZ0=AOi-tFaxvTY?&Q6
z0tEsE0tEsE0tEsEc7g)5XN#f~*!SgVPzMSG3fz<mi0?y`4q;=yU6$7SbWr7`0Axi9
z;1z099^l19eH-)bvb0_(ol|BH=!c@8VxSDC@u-+iHs;%9X=ON|3<vbDjDCiK-qk5C
z>P-iXNgLFG0)YZs6%ema8K_{wG}s&S_td;Imon`XjbBgAnTF%Gw5(xKamlXTr3x#f
zQc=dk6%P!}*z-fK>Smp|nwj)^hNh?d_Mqy{<lDoxZLYV~)Tp7)CwW!3ZMmvp>6s0o
zQwhV;?D@EzwKQjHNS-fYXzomsR}W_N9EA?5mOg4YM#?Y^_fbYgVM!iYTx@N>w<+4z
zvD6e@Y;9@jXo|L<XkA+3mlUPuNL$yy_}tR7E30q5_4eg=KL0}Mf&MoIDmUqKrI0wL
zlN*%c6xn%kepnZWg>LDo?(Iu*o^|vKx~aNGPVZ4&-AVF24(W9+ZCn0rBzZWkn&~V}
z(z{G^$aqY55^3Aa&RWixt1r01GvU}7x7%}$85ApgNxoOeaDL7;Y|9zdGY(l2;ob6m
zHHU9Ma`c{#`>s{&;bB(EsuMXOl&O!*3k}CrC#_qWVNFkvvX*OHH1rG$<9BS>QfGA;
z6$u?={6l3*qje3~nwX<`BcVvBR#7H}zdNH-E#2(4P#xo{GVIXW<SFV|1LF=GewZGn
z3~gl13fI_(sit&Ox?0#Vh4-^WPTqiYwz1<%7@OEw+Mb=I6*|)089J%(uapPHweMFQ
z_xzl0(dAE_j)iGe-G%N_QN~3?m!|1jU93Sq<GNUjY;dvj9DpV`1s7lf(qO?nJO|Ii
z3-BVm2CMKMd;p)o75EaqhO6)mtig})6Z{On!5{D^{Dp{R7{YR_z)C!Xx8h-p;vIMt
z@5WX<h8@_2aqPif9Kcab-~>*hhO=nl96o}}_zb>;ui_iHf~)vGeuSUORTbrtJR|%0
z8b71fw(lz;>A$Z<iEWYWt2)#B{~)<mE<oH{SyjEyCo{hOWH&v`ja+#sNme|D@{D+t
z-U#OY$bo~QL#(zC0waW=zTh#%ORsseiB|y=S7f(7)SwXWyvXaa#!$1MnHS4Zk5Y~C
zU2>H86lC)fIoipH%YMdp%hA)U%X^zR$bNmOmnj^#qW2Hrtq^t}6LeSMTlgM+fnVWw
zxK5~*Vi@;h1ZxPjTD%h*@Gfk`W^Bjfcmg}|B!Sk4XYm~N<1mg8aASmAnvlDQ(`aA@
z9n4}57w~a>0-waE@M!|@WxRy1;Om>vJDZ12TD)8cz1&d7GHq*`#`D<T7#j3;qyoiq
zRS}W@_ZI&Be@Cu8SX7`upuoSQ0G9L&^~C91g}&Y**N)Qh5FMh3dCSszAyj$kI9V?p
jC%gWKA+@74Rm8-6yDTkvsQl+Y1O)qku>X7H-Q3mR_b}=>

literal 0
HcmV?d00001

diff --git a/algorithms/.DS_Store b/algorithms/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..a033a0ae6c3097c0d1bd47e0d12c031d4ff9372c
GIT binary patch
literal 10244
zcmeHMU2GIp6h5adFw=!{m;TW5ySj?S7HknpAwaj=AHYglyKT3Bu+HvG+mY$aIy1Wk
zNt0@#QR7dP7!w~%1O%h;!3T}eL}LtS<V7PfV*GjV&G<l~KH!t*&YfLK3no4o4VjzF
zJ@=k_&b@QL`<=Uc?*IVCb80g{1OOy@xMa&IyFudZ{8^Mre9cmlNdAz|rVT4im5<Wd
zMb?2LKp;RMKp;RMKp;Ti|9}AfX7eP4gbeZkfdGL3fg%EYe~8e-Wz3gzLV8;VW!@2h
zWErWwL}kVcBqP3z`EpK3YN3R}m85V*|A>LYo%9jkF6PTQA%#1jfA~OuWb{uc=#5VO
zM?7=Dn2<ppAP^w17y*8EFNF+bA**NRpWhALahsZcVhl@4%a$x%CduWY<tr*yvhb?P
za8<avx@L84b={h}btzVvRx(E?Z7XN09hPC)aU-V<>lw>T=#OZ_u6E4jg%n%0z^-3Y
zk6cp?9M6(X)is6J*M3{m%&|#ZS9>QW9L*h`R~|{Rl}^UC45QC-bXT{`k#T3rnmOod
z(+AB7i$=`r+DvbjH#tL^?T}pLGkn-k(wfn0#x2*irbiUpR?JB)ew<tK-e@9yw#Iw%
z#!h6FjBZXw+pY*Sqp`k1p<WaiL`4B08avbCl_iGqfN7bU9F6t(tr9dqJKP5en1UI2
z4qkz?@IIV}@8DPX6U(p$Z^s7Qj(f2U58wmXj{`V}qc|q~OZ=@6))z(-5>=A^n&uO>
zX;|hYX}EP6JOm2lK}pXz{#^}RO=rbgU&i7}mzS4Ul(TTf;RFGYa1}S_#1(tYtLdti
z_RD>WJ5?wTSe8*NE9oJEi&nG4GF?SCHG7`xcv3f2YbMV5;*2Lme@R_+r&6riN4ifj
zwISWn)4HL%$7M>AoMN>nPBgb{Z;b3{oo$SqXl`n1ZH%<+YMz~CCnag^<{j;aMzXU{
zpE`Z!^|R;R`1HIFM**fvQ7`5f<^y6l`95)ZRbmwY`L+m%99rI4-PN69EazzbnxVLQ
zUh7m`%~?#66bok*Ba<T|t=%v<^_^tKGIG<VQw)Yt$Ff}_I4O&faznb(#NS*|vv%Vh
zo44NEy7v-~Ke<w_PUbl{hBi3EaT`&bjAp9D%27hoboB{cv*j>;O_WonHQ`koS|hV}
zrE!(s>yV{#8`WzG)rK}m(iqow*c#<RE#DT3%1n_49GZdXVv}4iGe;gcN((4l8{{n#
zQ{_P~goLU|-X^ggIhhynCX_qmol+PZ<>8DqJxy=u2=(sJ9*KP}9pPi&uQ+aRRx@e%
zeQmKYy;aA}W+_P{+@oDpH8mRZqb?e25=+bYe~CJ1gniHtqqMh~6kX52vlL;^Q;eO4
zx8NQ45H7%H@C96iFX1vp-1qPU`~tth@9+mAmSYH4U<Fp<I$Vz%F@ksER=fwBaT~T`
zJI1jSyYLVWVUouqsyK}%X7OR1!>8~Cd>LQEQ+OKR#`o}J@m9rX-Crc2SHMq56yuU;
z=*MMA@`g0*uG-)A-_Y=~zxh{H*Z6FV7guw^0?y}>M<2ltk2eKgc+9+>jH_$w)`Zr{
z8*aAjgG4*+n8zcw?2>0q9OVRJlBjM9)l0;2R^nCVhR_zyU{)$xJ!YyhTOwMClbp@0
zOtkKniHkilTPj-H<aRHD7>N3&P?t=b_+q;K4cSf+)jlAiU4*aT8~71^hAVKD=(P;P
zxEgD5EzxTO-i7seH*NG=umyMGF5HcKh+N&Y<sZZzZ_7{OFwrbSG@HOl)X_!<bC}0t
z_$WSxkK+^gB$4h#Jc%#is|)CMU;*9E&8ORfpNH#BgIa(<fIxsifIxsifWR$?K&hBh
zgx~*n-TeFiEjaUFN&x}^0tE!HtTWLWr&{5rq|i{1{H{Gh&x7>v#O>yU^js*r?n3}o
y_;tK@FsC;ET<-bBNYDM}g!J60?zxi`xB372$AIAcFYaXj$u(4P{=cQp|9=6g)!oJb

literal 0
HcmV?d00001

diff --git a/algorithms/cpp/.DS_Store b/algorithms/cpp/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..4dfe7e1a95e6ba39857547c1dba471dfde0d32b4
GIT binary patch
literal 22532
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

literal 0
HcmV?d00001

diff --git a/algorithms/cpp/majorityElement/.DS_Store b/algorithms/cpp/majorityElement/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..2c13c8a8364e9d7d1fa8f26063f53c6c26cb691a
GIT binary patch
literal 6148
zcmeHK%Sr=55Ukc50$u`wc$}jr!9Q3+BJ9~8(8L^+)eT|}x$Ot~PiximC@!veQbf9;
zr+T`ldv*$T9sq2<yS)Hr0H#!-$rus2M?(i?u+VaiC*0u~do0n66#9!Uefu#UaD#ia
z`1t)BdN+9Fdd{)N7TdaM*Q=&oF++4+QqTG<w1AUutJJ8!sP&>+RO@?{3JC^+fnXpQ
z2nK$T0iM~C>5*f!!9Xw&47@X-{UK3>Rl&|NZyjuOeO7!Tl+f1YSeOb{1v^JZDCVg|
zPqp&IFi)pHm2p+U&e79hd1lrrGrv7vEYD7V%EMumW3<6QFfe4`(7Q98|4aTdqmTSy
zO7wz(VBnuIV3WnwV$MaCv-Q*Rbk-*7HC3W<oeT=?!6kql?IWi-=<y_*<Enz4qpHZC
Q(}{5r$b>`_4EzEEuY7GR(EtDd

literal 0
HcmV?d00001

diff --git a/algorithms/cpp/majorityElement/majorityElement.II.cpp b/algorithms/cpp/majorityElement/majorityElement.II.cpp
index 827e97a57..08b675d69 100644
--- a/algorithms/cpp/majorityElement/majorityElement.II.cpp
+++ b/algorithms/cpp/majorityElement/majorityElement.II.cpp
@@ -36,7 +36,7 @@ class Solution {
         //the same algorithm as Majority Element I problem
         int majority1=0, majority2=0, cnt1=0, cnt2=0;
         for(auto item: nums) {
-            if (cnt1 == 0) {
+            if (cnt1 == 0 && majority2 != item ) {
                 majority1 = item;
                 cnt1 = 1;
             } else if (majority1 == item) {

From a28233dd0be4ed11eb2f65815e997e2bb12486b7 Mon Sep 17 00:00:00 2001
From: wilsoncao <275239608@qq.com>
Date: Sat, 13 Feb 2016 19:32:31 -0500
Subject: [PATCH 31/54] update

---
 .DS_Store                                | Bin 8196 -> 0 bytes
 algorithms/.DS_Store                     | Bin 10244 -> 0 bytes
 algorithms/cpp/.DS_Store                 | Bin 22532 -> 0 bytes
 algorithms/cpp/majorityElement/.DS_Store | Bin 6148 -> 0 bytes
 4 files changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 .DS_Store
 delete mode 100644 algorithms/.DS_Store
 delete mode 100644 algorithms/cpp/.DS_Store
 delete mode 100644 algorithms/cpp/majorityElement/.DS_Store

diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index a88d1f977020681eb1ce37775d2046438f4c31e7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8196
zcmeI1T}&KR6vxj2TIRAs?-ppcrP4JhQh^FpC?&OBmXEeUQc^yaFI{JMrZ91s!JXL!
zB_wE~QR7FnF(y8k2x^VS2Oso7AB-_pV_!5jMvVI6n@=X{L*G1i?ku6e`ec-(bCbE}
z-gEDnx$~dj%+1*a0E}m~R)7cqD0B$RLsV^3#JD)Nlp^0#LKZ0=AOi-tFaxvTY?&Q6
z0tEsE0tEsE0tEsEc7g)5XN#f~*!SgVPzMSG3fz<mi0?y`4q;=yU6$7SbWr7`0Axi9
z;1z099^l19eH-)bvb0_(ol|BH=!c@8VxSDC@u-+iHs;%9X=ON|3<vbDjDCiK-qk5C
z>P-iXNgLFG0)YZs6%ema8K_{wG}s&S_td;Imon`XjbBgAnTF%Gw5(xKamlXTr3x#f
zQc=dk6%P!}*z-fK>Smp|nwj)^hNh?d_Mqy{<lDoxZLYV~)Tp7)CwW!3ZMmvp>6s0o
zQwhV;?D@EzwKQjHNS-fYXzomsR}W_N9EA?5mOg4YM#?Y^_fbYgVM!iYTx@N>w<+4z
zvD6e@Y;9@jXo|L<XkA+3mlUPuNL$yy_}tR7E30q5_4eg=KL0}Mf&MoIDmUqKrI0wL
zlN*%c6xn%kepnZWg>LDo?(Iu*o^|vKx~aNGPVZ4&-AVF24(W9+ZCn0rBzZWkn&~V}
z(z{G^$aqY55^3Aa&RWixt1r01GvU}7x7%}$85ApgNxoOeaDL7;Y|9zdGY(l2;ob6m
zHHU9Ma`c{#`>s{&;bB(EsuMXOl&O!*3k}CrC#_qWVNFkvvX*OHH1rG$<9BS>QfGA;
z6$u?={6l3*qje3~nwX<`BcVvBR#7H}zdNH-E#2(4P#xo{GVIXW<SFV|1LF=GewZGn
z3~gl13fI_(sit&Ox?0#Vh4-^WPTqiYwz1<%7@OEw+Mb=I6*|)089J%(uapPHweMFQ
z_xzl0(dAE_j)iGe-G%N_QN~3?m!|1jU93Sq<GNUjY;dvj9DpV`1s7lf(qO?nJO|Ii
z3-BVm2CMKMd;p)o75EaqhO6)mtig})6Z{On!5{D^{Dp{R7{YR_z)C!Xx8h-p;vIMt
z@5WX<h8@_2aqPif9Kcab-~>*hhO=nl96o}}_zb>;ui_iHf~)vGeuSUORTbrtJR|%0
z8b71fw(lz;>A$Z<iEWYWt2)#B{~)<mE<oH{SyjEyCo{hOWH&v`ja+#sNme|D@{D+t
z-U#OY$bo~QL#(zC0waW=zTh#%ORsseiB|y=S7f(7)SwXWyvXaa#!$1MnHS4Zk5Y~C
zU2>H86lC)fIoipH%YMdp%hA)U%X^zR$bNmOmnj^#qW2Hrtq^t}6LeSMTlgM+fnVWw
zxK5~*Vi@;h1ZxPjTD%h*@Gfk`W^Bjfcmg}|B!Sk4XYm~N<1mg8aASmAnvlDQ(`aA@
z9n4}57w~a>0-waE@M!|@WxRy1;Om>vJDZ12TD)8cz1&d7GHq*`#`D<T7#j3;qyoiq
zRS}W@_ZI&Be@Cu8SX7`upuoSQ0G9L&^~C91g}&Y**N)Qh5FMh3dCSszAyj$kI9V?p
jC%gWKA+@74Rm8-6yDTkvsQl+Y1O)qku>X7H-Q3mR_b}=>

diff --git a/algorithms/.DS_Store b/algorithms/.DS_Store
deleted file mode 100644
index a033a0ae6c3097c0d1bd47e0d12c031d4ff9372c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10244
zcmeHMU2GIp6h5adFw=!{m;TW5ySj?S7HknpAwaj=AHYglyKT3Bu+HvG+mY$aIy1Wk
zNt0@#QR7dP7!w~%1O%h;!3T}eL}LtS<V7PfV*GjV&G<l~KH!t*&YfLK3no4o4VjzF
zJ@=k_&b@QL`<=Uc?*IVCb80g{1OOy@xMa&IyFudZ{8^Mre9cmlNdAz|rVT4im5<Wd
zMb?2LKp;RMKp;RMKp;Ti|9}AfX7eP4gbeZkfdGL3fg%EYe~8e-Wz3gzLV8;VW!@2h
zWErWwL}kVcBqP3z`EpK3YN3R}m85V*|A>LYo%9jkF6PTQA%#1jfA~OuWb{uc=#5VO
zM?7=Dn2<ppAP^w17y*8EFNF+bA**NRpWhALahsZcVhl@4%a$x%CduWY<tr*yvhb?P
za8<avx@L84b={h}btzVvRx(E?Z7XN09hPC)aU-V<>lw>T=#OZ_u6E4jg%n%0z^-3Y
zk6cp?9M6(X)is6J*M3{m%&|#ZS9>QW9L*h`R~|{Rl}^UC45QC-bXT{`k#T3rnmOod
z(+AB7i$=`r+DvbjH#tL^?T}pLGkn-k(wfn0#x2*irbiUpR?JB)ew<tK-e@9yw#Iw%
z#!h6FjBZXw+pY*Sqp`k1p<WaiL`4B08avbCl_iGqfN7bU9F6t(tr9dqJKP5en1UI2
z4qkz?@IIV}@8DPX6U(p$Z^s7Qj(f2U58wmXj{`V}qc|q~OZ=@6))z(-5>=A^n&uO>
zX;|hYX}EP6JOm2lK}pXz{#^}RO=rbgU&i7}mzS4Ul(TTf;RFGYa1}S_#1(tYtLdti
z_RD>WJ5?wTSe8*NE9oJEi&nG4GF?SCHG7`xcv3f2YbMV5;*2Lme@R_+r&6riN4ifj
zwISWn)4HL%$7M>AoMN>nPBgb{Z;b3{oo$SqXl`n1ZH%<+YMz~CCnag^<{j;aMzXU{
zpE`Z!^|R;R`1HIFM**fvQ7`5f<^y6l`95)ZRbmwY`L+m%99rI4-PN69EazzbnxVLQ
zUh7m`%~?#66bok*Ba<T|t=%v<^_^tKGIG<VQw)Yt$Ff}_I4O&faznb(#NS*|vv%Vh
zo44NEy7v-~Ke<w_PUbl{hBi3EaT`&bjAp9D%27hoboB{cv*j>;O_WonHQ`koS|hV}
zrE!(s>yV{#8`WzG)rK}m(iqow*c#<RE#DT3%1n_49GZdXVv}4iGe;gcN((4l8{{n#
zQ{_P~goLU|-X^ggIhhynCX_qmol+PZ<>8DqJxy=u2=(sJ9*KP}9pPi&uQ+aRRx@e%
zeQmKYy;aA}W+_P{+@oDpH8mRZqb?e25=+bYe~CJ1gniHtqqMh~6kX52vlL;^Q;eO4
zx8NQ45H7%H@C96iFX1vp-1qPU`~tth@9+mAmSYH4U<Fp<I$Vz%F@ksER=fwBaT~T`
zJI1jSyYLVWVUouqsyK}%X7OR1!>8~Cd>LQEQ+OKR#`o}J@m9rX-Crc2SHMq56yuU;
z=*MMA@`g0*uG-)A-_Y=~zxh{H*Z6FV7guw^0?y}>M<2ltk2eKgc+9+>jH_$w)`Zr{
z8*aAjgG4*+n8zcw?2>0q9OVRJlBjM9)l0;2R^nCVhR_zyU{)$xJ!YyhTOwMClbp@0
zOtkKniHkilTPj-H<aRHD7>N3&P?t=b_+q;K4cSf+)jlAiU4*aT8~71^hAVKD=(P;P
zxEgD5EzxTO-i7seH*NG=umyMGF5HcKh+N&Y<sZZzZ_7{OFwrbSG@HOl)X_!<bC}0t
z_$WSxkK+^gB$4h#Jc%#is|)CMU;*9E&8ORfpNH#BgIa(<fIxsifIxsifWR$?K&hBh
zgx~*n-TeFiEjaUFN&x}^0tE!HtTWLWr&{5rq|i{1{H{Gh&x7>v#O>yU^js*r?n3}o
y_;tK@FsC;ET<-bBNYDM}g!J60?zxi`xB372$AIAcFYaXj$u(4P{=cQp|9=6g)!oJb

diff --git a/algorithms/cpp/.DS_Store b/algorithms/cpp/.DS_Store
deleted file mode 100644
index 4dfe7e1a95e6ba39857547c1dba471dfde0d32b4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 22532
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

diff --git a/algorithms/cpp/majorityElement/.DS_Store b/algorithms/cpp/majorityElement/.DS_Store
deleted file mode 100644
index 2c13c8a8364e9d7d1fa8f26063f53c6c26cb691a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHK%Sr=55Ukc50$u`wc$}jr!9Q3+BJ9~8(8L^+)eT|}x$Ot~PiximC@!veQbf9;
zr+T`ldv*$T9sq2<yS)Hr0H#!-$rus2M?(i?u+VaiC*0u~do0n66#9!Uefu#UaD#ia
z`1t)BdN+9Fdd{)N7TdaM*Q=&oF++4+QqTG<w1AUutJJ8!sP&>+RO@?{3JC^+fnXpQ
z2nK$T0iM~C>5*f!!9Xw&47@X-{UK3>Rl&|NZyjuOeO7!Tl+f1YSeOb{1v^JZDCVg|
zPqp&IFi)pHm2p+U&e79hd1lrrGrv7vEYD7V%EMumW3<6QFfe4`(7Q98|4aTdqmTSy
zO7wz(VBnuIV3WnwV$MaCv-Q*Rbk-*7HC3W<oeT=?!6kql?IWi-=<y_*<Enz4qpHZC
Q(}{5r$b>`_4EzEEuY7GR(EtDd


From 4727c83e154ef058b9ff8112bc3210801164e886 Mon Sep 17 00:00:00 2001
From: Siwei Xu <xusiwei1236@163.com>
Date: Fri, 26 Feb 2016 01:10:40 +0800
Subject: [PATCH 32/54] another solution for "Reverse Words in a String"

---
 .../reverseWordsInAString.cpp                 | 32 +++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp b/algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp
index b3f4d6147..33e79f882 100644
--- a/algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp
+++ b/algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp
@@ -1,5 +1,5 @@
 // Source : https://oj.leetcode.com/problems/reverse-words-in-a-string/
-// Author : Hao Chen
+// Author : Hao Chen, Siwei Xu
 // Date   : 2014-06-16
 
 /********************************************************************************** 
@@ -71,7 +71,35 @@ void reverseWords(string &s) {
     }
     cout << "[" << s << "]" <<endl;
 }
-    
+
+// inspired from <Programming Pearls> -- Handwaving
+void reverseWords2(string &s) {
+    if (s.length() == 0) return;
+
+    string result = "";
+    if (s[s.length()-1] == ' ') {
+        int last = s.find_last_not_of(' ') + 1;
+        s.erase(last, s.length() - last);
+    }
+
+    int first = s.find_first_not_of(' ', 0);
+    while (first != string::npos) {
+        int wend = s.find(' ', first);  // word end
+        if (wend == string::npos) wend = s.length();
+
+        string word = s.substr(first, wend - first);
+        reverse(word.begin(), word.end());
+        result += word;
+
+        first = s.find_first_not_of(' ', wend); // next word
+        if (first == string::npos) break;
+
+        result += ' ';
+    }
+    reverse(result.begin(), result.end());
+    s.swap(result);
+}
+
 main()
 {
    string s;

From 5c5363e9ae15c765e90510b9cd88dcad84e61f69 Mon Sep 17 00:00:00 2001
From: Siwei Xu <xusiwei1236@163.com>
Date: Fri, 26 Feb 2016 01:11:36 +0800
Subject: [PATCH 33/54] fix typo caused build error

---
 algorithms/cpp/maximalRectangle/maximalRectangle.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/algorithms/cpp/maximalRectangle/maximalRectangle.cpp b/algorithms/cpp/maximalRectangle/maximalRectangle.cpp
index 5e0a8fd81..4f732ed73 100644
--- a/algorithms/cpp/maximalRectangle/maximalRectangle.cpp
+++ b/algorithms/cpp/maximalRectangle/maximalRectangle.cpp
@@ -56,7 +56,7 @@ int maximalRectangle(vector<vector<char> > &matrix) {
     if (matrix.size()<=0 || matrix[0].size()<=0) return 0;
     int row = matrix.size();
     int col = matrix[0].size();
-    vector< vector<int> > heights(row, vector<int> col);
+    vector< vector<int> > heights(row, vector<int>(col));
 
     int maxArea = 0;
     for(int i=0; i<row; i++){

From 0f33a8dfaba7735bc7d64d42b193d9b13dc841c4 Mon Sep 17 00:00:00 2001
From: Siwei Xu <xusiwei1236@163.com>
Date: Sun, 28 Feb 2016 00:22:11 +0800
Subject: [PATCH 34/54] C solution for "Reverse Words in a String", in O(1)
 space

---
 .../reverseWordsInAString.cpp                 | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp b/algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp
index 33e79f882..89edd1062 100644
--- a/algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp
+++ b/algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp
@@ -24,9 +24,13 @@
 **********************************************************************************/
 
 #include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <iostream>
 #include <string>
 #include <vector>
+#include <algorithm>  // for std::reverse
 using namespace std;
 
 void reverseWords(string &s) {
@@ -100,6 +104,53 @@ void reverseWords2(string &s) {
     s.swap(result);
 }
 
+
+// C solution in O(1) space
+void reverse(char *b, char *e) {
+    for (--e; e - b > 0; b++, e--) {
+        char t = *b;
+        *b = *e;
+        *e = t;
+    }
+}
+
+void reverseWords(char *s) {
+    char *p = s, *ws = NULL, *last = s;
+
+    while (*p && *p == ' ') p++; // skip leading space
+    ws = p;
+
+    for ( ; *p; p++) {
+        while (*p && *p != ' ') p++; // find word end
+
+        reverse(ws, p);
+        strncpy(last, ws, p-ws);
+        last += (p-ws);
+
+        while (*p && *p == ' ') p++; // for next word
+        ws = p;
+
+        if (*p == '\0') break;
+        *last++ = ' ';
+    }
+    reverse(s, last);
+    *last = '\0';
+}
+
+void test() {
+#define TEST(str) do {       \
+    char* s = strdup(str);   \
+    printf("\"%s\" => ", s); \
+    reverseWords(s);         \
+    printf("\"%s\"\n\n", s); \
+    free(s);                 \
+    } while (0)
+
+    TEST("  the    blue   sky  is blue    ");
+    TEST("  ");
+}
+
+
 main()
 {
    string s;
@@ -113,4 +164,5 @@ main()
    s="i love cpp";
    reverseWords(s);
 
+   test();
 }    

From be582a0f5fb5b9e14f098fb031c8a58471b2ab5a Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Sat, 27 Feb 2016 19:40:31 +0200
Subject: [PATCH 35/54] added increasingTripletSubsequence

---
 README.md                                     |  1 +
 .../increasingTripletSubsequence.cpp          | 43 +++++++++++++++++++
 2 files changed, 44 insertions(+)
 create mode 100644 algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp

diff --git a/README.md b/README.md
index 6d410f75a..47982b36d 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
 |329|[Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/) | [C++](./algorithms/cpp/longestIncreasingPathInAMatrix/LongestIncreasingPathInAMatrix.cpp)|Medium|
 |328|[Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/) | [C++](./algorithms/cpp/oddEvenLinkedList/OddEvenLinkedList.cpp)|Easy|
 |327|[Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/) | [C++](./algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp)|Hard|
diff --git a/algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp b/algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp
new file mode 100644
index 000000000..a53f3d7bd
--- /dev/null
+++ b/algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp
@@ -0,0 +1,43 @@
+// Source : https://leetcode.com/problems/increasing-triplet-subsequence/
+// Author : Calinescu Valentin
+// Date   : 2016-02-27
+
+/*************************************************************************************** 
+ *
+ * Given an unsorted array return whether an increasing subsequence of length 3 exists
+ * or not in the array.
+ * 
+ * Formally the function should:
+ * Return true if there exists i, j, k 
+ * such that arr[i] < arr[j] < arr[k] given 0 ≤ i < j < k ≤ n-1 else return false.
+ * Your algorithm should run in O(n) time complexity and O(1) space complexity.
+ * 
+ * Examples:
+ * Given [1, 2, 3, 4, 5],
+ * return true.
+ * 
+ * Given [5, 4, 3, 2, 1],
+ * return false.
+ * 
+ ***************************************************************************************/
+class Solution {
+public:
+    bool increasingTriplet(vector<int>& nums) {
+        bool solution = false;
+        if(nums.size())
+        {
+            int first = nums[0];
+            int second = 0x7fffffff; //MAX_INT so we can always find something smaller than it
+            for(int i = 1; i < nums.size() && !solution; i++)
+            {
+                if(nums[i] > second)
+                    solution = true;
+                else if(nums[i] > first && nums[i] < second)
+                    second = nums[i];
+                else if(nums[i] < first)
+                    first = nums[i];
+            }
+        }
+        return solution;
+    }
+};

From e8e1847fb62402771f6a5a48eb4bdbd803fed30c Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Mon, 29 Feb 2016 17:38:33 +0800
Subject: [PATCH 36/54] refine the comments

---
 algorithms/cpp/nextPermutation/nextPermutation.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/algorithms/cpp/nextPermutation/nextPermutation.cpp b/algorithms/cpp/nextPermutation/nextPermutation.cpp
index 404c4b86c..8d4ab294e 100644
--- a/algorithms/cpp/nextPermutation/nextPermutation.cpp
+++ b/algorithms/cpp/nextPermutation/nextPermutation.cpp
@@ -33,11 +33,11 @@
  *    2 1 3 4
  *    ...
  *
- * The pattern as below:
+ * The pattern can be descripted as below:
  *
- *    1) find the first place which num[i-1] < num[i]
- *    2) find the first number from n-1 to i which >= num[i-1]
- *    3) swap the 2) num with num[i-1]
+ *    1) from n-1 to 0, find the first place [i-1] which num[i-1] < num[i]
+ *    2) from n-1 to i, find the first number from n-1 to i which >= num[i-1]
+ *    3) swap the 2) num with the num[i-1]
  *    4) sort the sub-array [i, n) //actuall sort is fine as well
  * 
  * For example:

From 23801d8650fb79bd0d768e3e19f8b19f0d50219e Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Mon, 29 Feb 2016 17:43:33 +0800
Subject: [PATCH 37/54] fix #96

---
 algorithms/cpp/3Sum/3Sum.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/algorithms/cpp/3Sum/3Sum.cpp b/algorithms/cpp/3Sum/3Sum.cpp
index 0b38716e4..711550183 100644
--- a/algorithms/cpp/3Sum/3Sum.cpp
+++ b/algorithms/cpp/3Sum/3Sum.cpp
@@ -71,7 +71,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--;

From da6bc7c890e8d36e3711f8a2d3bccbd2d06ef91a Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Tue, 1 Mar 2016 00:45:30 +0800
Subject: [PATCH 38/54] New Problem "Patching Array"

---
 README.md                                     |   1 +
 .../cpp/patchingArray/PatchingArray.cpp       | 115 ++++++++++++++++++
 2 files changed, 116 insertions(+)
 create mode 100644 algorithms/cpp/patchingArray/PatchingArray.cpp

diff --git a/README.md b/README.md
index 47982b36d..cc9b9f4be 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,7 @@ LeetCode
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
+|330|[Patching Array](https://leetcode.com/problems/patching-array/) | [C++](./algorithms/cpp/patchingArray/PatchingArray.cpp)|Medium|
 |329|[Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/) | [C++](./algorithms/cpp/longestIncreasingPathInAMatrix/LongestIncreasingPathInAMatrix.cpp)|Medium|
 |328|[Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/) | [C++](./algorithms/cpp/oddEvenLinkedList/OddEvenLinkedList.cpp)|Easy|
 |327|[Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/) | [C++](./algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp)|Hard|
diff --git a/algorithms/cpp/patchingArray/PatchingArray.cpp b/algorithms/cpp/patchingArray/PatchingArray.cpp
new file mode 100644
index 000000000..18b7ee51b
--- /dev/null
+++ b/algorithms/cpp/patchingArray/PatchingArray.cpp
@@ -0,0 +1,115 @@
+// Source : https://leetcode.com/problems/patching-array/
+// Author : Hao Chen
+// Date   : 2016-03-01
+
+/*************************************************************************************** 
+ *
+ * Given a sorted positive integer array nums and an integer n, add/patch elements to 
+ * the array such that any number in range [1, n] inclusive can be formed by the sum of 
+ * some elements in the array. Return the minimum number of patches required.
+ * 
+ * Example 1:
+ * nums = [1, 3], n = 6
+ * Return 1.
+ * 
+ * Combinations of nums are [1], [3], [1,3], which form possible sums of: 1, 3, 4.
+ * Now if we add/patch 2 to nums, the combinations are: [1], [2], [3], [1,3], [2,3], 
+ * [1,2,3].
+ * Possible sums are 1, 2, 3, 4, 5, 6, which now covers the range [1, 6].
+ * So we only need 1 patch.
+ * 
+ * Example 2:
+ * nums = [1, 5, 10], n = 20
+ * Return 2.
+ * The two patches can be [2, 4].
+ * 
+ * Example 3:
+ * nums = [1, 2, 2], n = 5
+ * Return 0.
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ ***************************************************************************************/
+
+
+class Solution {
+public:
+    int minPatches(vector<int>& nums, int n) {
+        return minPatches_02(nums, n);
+        return minPatches_01(nums, n);
+    }
+    
+    
+    // Greedy Algorithm
+    // (Assume the array is sorted already)
+    //
+    //   Let do some observation at first,
+    //
+    //     1) if we have [1,2] then we can cover 1, 2, 3
+    //     2) if we have [1,2,3] then we can cover 1,2,3,4,5,6
+    //     So, it looks we can simply add all of nums together, then we can find out max number we can reach.
+    //
+    //     3) if we have [1,2,5], we can see 
+    //       3.1) [1,2] can cover 1,2,3, but we cannot reach 4, 
+    //       3.2) then we patch 4, then we have [1,2,4] which can cover 1,2,3(1+2),4,5(1+4),6(2+4), 7(1+2+4)
+    //       3.3) we can see [1,2,4] can reach to 7 - sum all of them
+    //       3.4) then [1,2,4,5], we can reach to 12 - 1,2,3,4,5,6,7,8(1+2+5),9(4+5),10(1+4+5), 11(2+4+5), 12(1+2+4+5)
+    //   
+    //   So, we can have figure out our solution
+    //
+    //      0) considering the `n` we need to cover.
+    //      1) maintain a variable we are trying to patch, suppose named `try_patch`
+    //      2) if `try_patch` >= nums[i] then, we just keep add the current array item, 
+    //         and set the `try_patch` to the next patch candidate number -  `sum+1`
+    //      3) if `try_patch` < nums[i], which means we need to patch.
+    //
+    int minPatches_01(vector<int>& nums, int n) {
+        long covered = 0; //avoid integer overflow
+        int patch_cnt = 0;
+        int i = 0;
+        while (i<nums.size() ){
+            // set the `try_patch` is the next number which we cannot cover
+            int try_patch = covered + 1;
+            // if the `try_patch` can cover the current item, then just sum it, 
+            // then we can have the max number we can cover so far 
+            if ( try_patch >= nums[i])  {
+                covered += nums[i];  
+                i++;
+            } else { // if the `try_patch` cannot cover the current item, then we find the number we need to patch
+                patch_cnt++;
+                //cout << "patch " << try_patch << endl;
+                covered = covered + try_patch;
+            } 
+            
+            if (covered >=n) break;
+        }
+        //for the case - [1], 7
+        //the above while-loop just process all of the numbers in the array, 
+        //but we might not reach the goal, so, we need keep patching.
+        while (covered < n) {
+            int try_patch = covered + 1;
+            patch_cnt++;
+            //cout << "patch " << try_patch << endl;
+            covered = covered + try_patch;
+        }
+        return patch_cnt;
+    }
+    
+    
+    //The following solution just re-organizes the solution above, and make it shorter 
+    int minPatches_02(vector<int>& nums, int n) {
+        long covered = 0;
+        int patch_cnt = 0;
+        int i = 0;
+        while ( covered < n){
+            if (i<nums.size() && nums[i] <= covered + 1) {
+                covered += nums[i++];
+            }else{
+                //cout << "patch " << covered + 1 << endl;
+                covered = 2 * covered + 1;
+                patch_cnt++;
+            }
+        }
+        return patch_cnt;
+    }
+};

From 38f46e5e82910e75f92318c232f72af96e7c881b Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Fri, 29 Apr 2016 22:46:45 +0300
Subject: [PATCH 39/54] added houseRobberIII

---
 README.md                                     |  1 +
 algorithms/cpp/houseRobber/houseRobberIII.cpp | 88 +++++++++++++++++++
 2 files changed, 89 insertions(+)
 create mode 100644 algorithms/cpp/houseRobber/houseRobberIII.cpp

diff --git a/README.md b/README.md
index cc9b9f4be..8eb0c6e5f 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|337|[House Robber III](https://leetcode.com/problems/house-robber-iii/) | [C++](./algorithms/cpp/houseRobber/houseRobberIII.cpp)|Medium|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
 |330|[Patching Array](https://leetcode.com/problems/patching-array/) | [C++](./algorithms/cpp/patchingArray/PatchingArray.cpp)|Medium|
 |329|[Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/) | [C++](./algorithms/cpp/longestIncreasingPathInAMatrix/LongestIncreasingPathInAMatrix.cpp)|Medium|
diff --git a/algorithms/cpp/houseRobber/houseRobberIII.cpp b/algorithms/cpp/houseRobber/houseRobberIII.cpp
new file mode 100644
index 000000000..8bb4aeadf
--- /dev/null
+++ b/algorithms/cpp/houseRobber/houseRobberIII.cpp
@@ -0,0 +1,88 @@
+// Source : https://leetcode.com/problems/house-robber-iii/
+// Author : Calinescu Valentin
+// Date   : 2016-04-29
+
+/*************************************************************************************** 
+ *
+ * The thief has found himself a new place for his thievery again. There is only one
+ * entrance to this area, called the "root." Besides the root, each house has one and
+ * only one parent house. After a tour, the smart thief realized that "all houses in
+ * this place forms a binary tree". It will automatically contact the police if two 
+ * directly-linked houses were broken into on the same night.
+ * 
+ * Determine the maximum amount of money the thief can rob tonight without alerting the
+ * police.
+ * 
+ * Example 1:
+ *     3
+ *    / \
+ *   2   3
+ *    \   \ 
+ *     3   1
+ * Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
+ * Example 2:
+ *     3
+ *    / \
+ *   4   5
+ *  / \   \ 
+ * 1   3   1
+ * Maximum amount of money the thief can rob = 4 + 5 = 9.
+ * Credits:
+ * Special thanks to @dietpepsi for adding this problem and creating all test cases.
+ * 
+ ***************************************************************************************/
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+  /* 
+ * Solution 1 - O(N log N)
+ * =========
+ *
+ * We can use a recursive function that computes the solution for every node of the tree 
+ * using the previous solutions calculated for the left and right subtrees. At every step
+ * we have 2 options:
+ *
+ * 1) Take the value of the current node + the solution of the left and right subtrees of
+ * each of the left and right children of the current node.
+ * 2) Take the solution of the left and right subtrees of the current node, skipping over
+ * its value.
+ *
+ * This way we can make sure that we do not pick 2 adjacent nodes.
+ *
+ * If we implemented this right away we would get TLE. Thus, we need to optimize the
+ * algorithm. One key observation would be that we only need to compute the solution for
+ * a certain node once. We can use memoization to calculate every value once and then
+ * retrieve it when we get subsequent calls. As the header of the recursive function
+ * doesn't allow additional parameters we can use a map to link every node(a pointer) to
+ * its solution(an int). For every call the map lookup of an element and its insertion
+ * take logarithmic time and there are a constant number of calls for each node. Thus, the
+ * algorithm takes O(N log N) time to finish.
+ * 
+ */
+class Solution {
+public:
+    map<TreeNode*, int> dict;
+    int rob(TreeNode* root) {
+        if(root == NULL)
+            return 0;
+        else if(dict.find(root) == dict.end())
+        {
+            int lwith = rob(root->left);
+            int rwith = rob(root->right);
+            int lwithout = 0, rwithout = 0;
+            if(root->left != NULL)
+                lwithout = rob(root->left->left) + rob(root->left->right);
+            if(root->right != NULL)
+                rwithout = rob(root->right->left) + rob(root->right->right);
+            //cout << lwith << " " << rwith << " " << lwithout << " " << rwithout << '\n';
+            dict[root] = max(root->val + lwithout + rwithout, lwith + rwith);
+        }
+        return dict[root];
+    }
+};

From d88cc15f7ab30c00d2dfc72d9a6ec0f82f30e8a9 Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Sat, 30 Apr 2016 17:34:02 +0300
Subject: [PATCH 40/54] added reverseVowelsOfAString

---
 README.md                                     |  1 +
 .../reverseVowelsOfAString.cpp                | 50 +++++++++++++++++++
 2 files changed, 51 insertions(+)
 create mode 100644 algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp

diff --git a/README.md b/README.md
index 8eb0c6e5f..16acd1391 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|345|[Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/) | [C++](./algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp)|Easy|
 |337|[House Robber III](https://leetcode.com/problems/house-robber-iii/) | [C++](./algorithms/cpp/houseRobber/houseRobberIII.cpp)|Medium|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
 |330|[Patching Array](https://leetcode.com/problems/patching-array/) | [C++](./algorithms/cpp/patchingArray/PatchingArray.cpp)|Medium|
diff --git a/algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp b/algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp
new file mode 100644
index 000000000..f4f63922a
--- /dev/null
+++ b/algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp
@@ -0,0 +1,50 @@
+// Source : https://leetcode.com/problems/reverse-vowels-of-a-string/
+// Author : Calinescu Valentin
+// Date   : 2016-04-30
+
+/*************************************************************************************** 
+ *
+ * Write a function that takes a string as input and reverse only the vowels of a 
+ * string.
+ * 
+ * Example 1:
+ * Given s = "hello", return "holle".
+ * 
+ * Example 2:
+ * Given s = "leetcode", return "leotcede".
+ * 
+ ***************************************************************************************/
+class Solution {
+public:
+    string reverseVowels(string s) {
+        list <char> vowels;
+        set <char> vows;
+        vows.insert('a');
+        vows.insert('A');
+        vows.insert('e');
+        vows.insert('E');
+        vows.insert('i');
+        vows.insert('I');
+        vows.insert('o');
+        vows.insert('O');
+        vows.insert('u');
+        vows.insert('U');
+        string result;
+        for(int i = 0; i < s.size(); i++)
+        {
+            if(vows.find(s[i]) != vows.end())
+                vowels.push_back(s[i]);
+        }
+        for(int i = 0; i < s.size(); i++)
+        {
+            if(vows.find(s[i]) != vows.end())
+            {
+                result.push_back(vowels.back());
+                vowels.pop_back();
+            }
+            else
+                result.push_back(s[i]);
+        }
+        return result;
+    }
+};

From a127523d15dc047452e1b0a79d167802b6958b3b Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Mon, 2 May 2016 23:13:48 +0300
Subject: [PATCH 41/54] added topKFrequentElements

---
 README.md                                     |  1 +
 .../topKFrequentElements.cpp                  | 65 +++++++++++++++++++
 2 files changed, 66 insertions(+)
 create mode 100644 algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp

diff --git a/README.md b/README.md
index 16acd1391..9362904c5 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | [C++](./algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp)|Medium|
 |345|[Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/) | [C++](./algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp)|Easy|
 |337|[House Robber III](https://leetcode.com/problems/house-robber-iii/) | [C++](./algorithms/cpp/houseRobber/houseRobberIII.cpp)|Medium|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
diff --git a/algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp b/algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp
new file mode 100644
index 000000000..245c3ba0b
--- /dev/null
+++ b/algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp
@@ -0,0 +1,65 @@
+// Source : https://leetcode.com/problems/top-k-frequent-elements/
+// Author : Calinescu Valentin
+// Date   : 2016-05-02
+
+/*************************************************************************************** 
+ *
+ * Given a non-empty array of integers, return the k most frequent elements.
+ * 
+ * For example,
+ * Given [1,1,1,2,2,3] and k = 2, return [1,2].
+ * 
+ * Note: 
+ * You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
+ * Your algorithm's time complexity must be better than O(n log n), where n is the 
+ * array's size.
+ * 
+ ***************************************************************************************/
+
+class Solution {
+public:
+    struct element//structure consisting of every distinct number in the vector,
+    //along with its frequency
+    {
+        int number, frequency;
+        bool operator < (const element arg) const
+        {
+            return frequency < arg.frequency;
+        }
+    };
+    priority_queue <element> sol;//we use a heap so we have all of the elements sorted
+    //by their frequency
+    vector <int> solution;
+    
+    vector<int> topKFrequent(vector<int>& nums, int k) {
+        sort(nums.begin(), nums.end());
+        int i = 1;
+        for(; i < nums.size(); i++)
+        {
+            int freq = 1;
+            while(i < nums.size() && nums[i] == nums[i - 1])
+            {
+                i++;
+                freq++;
+            }
+            element el;
+            el.number = nums[i - 1];
+            el.frequency = freq;
+            sol.push(el);
+        }
+        if(i == nums.size())//if we have 1 distinct element as the last
+        {
+            element el;
+            el.number = nums[nums.size() - 1];
+            el.frequency = 1;
+            sol.push(el);
+        }
+        while(k)//we extract the first k elements from the heap
+        {
+            solution.push_back(sol.top().number);
+            sol.pop();
+            k--;
+        }
+        return solution;
+    }
+};

From 43156ff0bf6a5241b030bb31ea2dc216903b8a3a Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Fri, 20 May 2016 14:46:16 +0300
Subject: [PATCH 42/54] added intersectionOfTwoArrays

---
 README.md                                     |  1 +
 .../intersectionOfTwoArrays.cpp               | 31 +++++++++++++++++++
 2 files changed, 32 insertions(+)
 create mode 100644 algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp

diff --git a/README.md b/README.md
index 9362904c5..3b6e68aa7 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) | [C++](./algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp)|Easy|
 |347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | [C++](./algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp)|Medium|
 |345|[Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/) | [C++](./algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp)|Easy|
 |337|[House Robber III](https://leetcode.com/problems/house-robber-iii/) | [C++](./algorithms/cpp/houseRobber/houseRobberIII.cpp)|Medium|
diff --git a/algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp b/algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp
new file mode 100644
index 000000000..da8fe9046
--- /dev/null
+++ b/algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp
@@ -0,0 +1,31 @@
+// Source : https://leetcode.com/problems/intersection-of-two-arrays/
+// Author : Calinescu Valentin
+// Date   : 2016-05-20
+
+/*************************************************************************************** 
+ *
+ * Given two arrays, write a function to compute their intersection.
+ * 
+ * Example:
+ * Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].
+ * 
+ * Note:
+ * Each element in the result must be unique.
+ * The result can be in any order.
+ * 
+ ***************************************************************************************/
+class Solution {
+public:
+    set <int> inter1, inter2;//we use sets so as to avoid duplicates
+    vector <int> solution;
+    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
+        for(int i = 0; i < nums1.size(); i++)
+            inter1.insert(nums1[i]);//get all of the unique elements in nums1 sorted
+        for(int i = 0; i < nums2.size(); i++)
+            if(inter1.find(nums2[i]) != inter1.end())//search nums1 in O(logN)
+                inter2.insert(nums2[i]);//populate the intersection set
+        for(set<int>::iterator it = inter2.begin(); it != inter2.end(); ++it)
+            solution.push_back(*it);//copy the set into a vector
+        return solution;
+    }
+};

From 7d3ec8447afde81fb065499422d37e180b256d85 Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Fri, 20 May 2016 14:48:38 +0300
Subject: [PATCH 43/54] fixed typo

---
 .../cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp b/algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp
index da8fe9046..0b20ecc77 100644
--- a/algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp
+++ b/algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp
@@ -22,7 +22,7 @@ class Solution {
         for(int i = 0; i < nums1.size(); i++)
             inter1.insert(nums1[i]);//get all of the unique elements in nums1 sorted
         for(int i = 0; i < nums2.size(); i++)
-            if(inter1.find(nums2[i]) != inter1.end())//search nums1 in O(logN)
+            if(inter1.find(nums2[i]) != inter1.end())//search inter1 in O(logN)
                 inter2.insert(nums2[i]);//populate the intersection set
         for(set<int>::iterator it = inter2.begin(); it != inter2.end(); ++it)
             solution.push_back(*it);//copy the set into a vector

From 96f799f843841463d31f6fea6f82be7aed2b9771 Mon Sep 17 00:00:00 2001
From: Vally <vally_ersaro@yahoo.com>
Date: Sun, 22 May 2016 16:47:42 +0300
Subject: [PATCH 44/54] added intersectionOfTwoArraysII

---
 README.md                                     |  1 +
 .../intersectionOfTwoArraysII.cpp             | 61 +++++++++++++++++++
 2 files changed, 62 insertions(+)
 create mode 100644 algorithms/cpp/intersectionOfTwoArraysII/intersectionOfTwoArraysII.cpp

diff --git a/README.md b/README.md
index 3b6e68aa7..8084bd918 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|350|[Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/) | [C++](./algorithms/cpp/intersectionOfTwoArraysII/intersectionOfTwoArraysII.cpp)|Easy|
 |349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) | [C++](./algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp)|Easy|
 |347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | [C++](./algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp)|Medium|
 |345|[Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/) | [C++](./algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp)|Easy|
diff --git a/algorithms/cpp/intersectionOfTwoArraysII/intersectionOfTwoArraysII.cpp b/algorithms/cpp/intersectionOfTwoArraysII/intersectionOfTwoArraysII.cpp
new file mode 100644
index 000000000..3b20ef791
--- /dev/null
+++ b/algorithms/cpp/intersectionOfTwoArraysII/intersectionOfTwoArraysII.cpp
@@ -0,0 +1,61 @@
+// Source : https://leetcode.com/problems/intersection-of-two-arrays-ii/
+// Author : Calinescu Valentin
+// Date   : 2016-05-22
+
+/*************************************************************************************** 
+ *
+ * Given two arrays, write a function to compute their intersection.
+ * 
+ * Example:
+ * Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2, 2].
+ * 
+ * Note:
+ * Each element in the result should appear as many times as it shows in both arrays.
+ * The result can be in any order.
+ * 
+ * Follow up:
+ * What if the given array is already sorted? How would you optimize your algorithm?
+ * What if nums1's size is small compared to num2's size? Which algorithm is better?
+ * What if elements of nums2 are stored on disk, and the memory is limited such that you
+ * cannot load all elements into the memory at once?
+ * 
+ ***************************************************************************************/
+ 
+ /* Solution
+  * --------
+  *
+  * Follow up:
+  * 
+  * 1)If the given array is already sorted we can skip the sorting.
+  * 
+  * 2)If nums1 is significantly smaller than nums2 we can only sort nums1 and then binary
+  * search every element of nums2 in nums1 with a total complexity of (MlogN) or if nums2
+  * is already sorted we can search every element of nums1 in nums2 in O(NlogM)
+  *
+  * 3)Just like 2), we can search for every element in nums2, thus having an online
+  * algorithm.
+  */
+  
+class Solution { // O(NlogN + MlogM)
+public:
+    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
+        sort(nums1.begin(), nums1.end());//we sort both vectors in order to intersect
+        sort(nums2.begin(), nums2.end());//them later in O(N + M), where N = nums1.size()
+        vector <int> solution;                                         //M = nums2.size() 
+        int index = 0;
+        bool finished = false;
+        for(int i = 0; i < nums1.size() && !finished; i++)
+        {
+            while(index < nums2.size() && nums1[i] > nums2[index])//we skip over the
+                index++;//smaller elements in nums2
+            if(index == nums2.size())//we have reached the end of nums2 so we have no more
+                finished = true;//elements to add to the intersection
+            else if(nums1[i] == nums2[index])//we found a common element
+            {
+                solution.push_back(nums1[i]);
+                index++;
+            }
+        }
+        return solution;
+    }
+};

From cf12236261b84d2f965562a227139fa412c4e7d1 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sun, 29 May 2016 15:37:31 +0800
Subject: [PATCH 45/54] the solution of the problem "Reverse String"

---
 README.md                                     |  1 +
 .../cpp/reverseString/ReverseString.cpp       | 24 +++++++++++++++++++
 2 files changed, 25 insertions(+)
 create mode 100644 algorithms/cpp/reverseString/ReverseString.cpp

diff --git a/README.md b/README.md
index 8084bd918..cf2cb7155 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,7 @@ LeetCode
 |349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) | [C++](./algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp)|Easy|
 |347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | [C++](./algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp)|Medium|
 |345|[Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/) | [C++](./algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp)|Easy|
+|345|[Reverse String](https://leetcode.com/problems/reverse-string/) | [C++](./algorithms/cpp/reverseString/ReverseString.cpp)|Easy|
 |337|[House Robber III](https://leetcode.com/problems/house-robber-iii/) | [C++](./algorithms/cpp/houseRobber/houseRobberIII.cpp)|Medium|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
 |330|[Patching Array](https://leetcode.com/problems/patching-array/) | [C++](./algorithms/cpp/patchingArray/PatchingArray.cpp)|Medium|
diff --git a/algorithms/cpp/reverseString/ReverseString.cpp b/algorithms/cpp/reverseString/ReverseString.cpp
new file mode 100644
index 000000000..c0f41088b
--- /dev/null
+++ b/algorithms/cpp/reverseString/ReverseString.cpp
@@ -0,0 +1,24 @@
+// Source : https://leetcode.com/problems/reverse-string/
+// Author : Hao Chen
+// Date   : 2016-05-29
+
+/*************************************************************************************** 
+ *
+ * Write a function that takes a string as input and returns the string reversed.
+ * 
+ * Example:
+ * Given s = "hello", return "olleh".
+ ***************************************************************************************/
+
+class Solution {
+public:
+    string reverseString(string s) {
+        int len = s.size();
+        for (int i=0; i<len/2; i++) {
+           char ch = s[i];
+           s[i] = s[len-i-1];
+           s[len-i-1] = ch;
+        } 
+        return s;
+    }
+};

From 32ce9621155f2b772279900aa0d5754af4a42e57 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sun, 29 May 2016 15:58:40 +0800
Subject: [PATCH 46/54] make the script can detect the author name
 automatically

---
 scripts/comments.sh | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/scripts/comments.sh b/scripts/comments.sh
index 69a6a10b6..6fe2e15f2 100755
--- a/scripts/comments.sh
+++ b/scripts/comments.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 set -e
 
-AUTHOR="Hao Chen"
+AUTHOR="NOBODY"
 LEETCODE_URL=https://leetcode.com/problems/
 LEETCODE_NEW_URL=https://leetcode.com/problems/
 LEETCODE_OLD_URL=https://oj.leetcode.com/problems/
@@ -23,6 +23,18 @@ function usage()
     echo -e ""
 }
 
+function get_author_name()
+{
+    TRUE_CMD=`which true`
+    git=`type -P git || ${TRUE_CMD}`
+    if [ ! -z "${git}" ]; then
+       AUTHOR=`git config --get user.name`
+    else 
+       AUTHOR=`whoami`
+    fi
+}
+
+
 function detect_os()
 {
     platform='unknown'
@@ -138,6 +150,9 @@ if [ ! -s $source_file ]; then
     echo "" > $source_file 
 fi
 
+#detect the author name
+get_author_name;
+
 #adding the Copyright Comments
 if  ! grep -Fq  "${COMMENT_TAG} Author :" $source_file ; then
     sed -i.bak '1i\'$'\n'"${COMMENT_TAG} Source : ${leetcode_url}"$'\n' $source_file

From 13eef8ddee74bd3727e74b911c67925433bea17d Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sun, 29 May 2016 16:13:33 +0800
Subject: [PATCH 47/54] the solution of problem "Power of Four"

---
 README.md                                  |  3 +-
 algorithms/cpp/powerOfFour/PowerOfFour.cpp | 37 ++++++++++++++++++++++
 2 files changed, 39 insertions(+), 1 deletion(-)
 create mode 100644 algorithms/cpp/powerOfFour/PowerOfFour.cpp

diff --git a/README.md b/README.md
index cf2cb7155..b3535e609 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,8 @@ LeetCode
 |349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) | [C++](./algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp)|Easy|
 |347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | [C++](./algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp)|Medium|
 |345|[Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/) | [C++](./algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp)|Easy|
-|345|[Reverse String](https://leetcode.com/problems/reverse-string/) | [C++](./algorithms/cpp/reverseString/ReverseString.cpp)|Easy|
+|344|[Reverse String](https://leetcode.com/problems/reverse-string/) | [C++](./algorithms/cpp/reverseString/ReverseString.cpp)|Easy|
+|342|[Power of Four](https://leetcode.com/problems/power-of-four/) | [C++](./algorithms/cpp/powerOfFour/PowerOfFour.cpp)|Easy|
 |337|[House Robber III](https://leetcode.com/problems/house-robber-iii/) | [C++](./algorithms/cpp/houseRobber/houseRobberIII.cpp)|Medium|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
 |330|[Patching Array](https://leetcode.com/problems/patching-array/) | [C++](./algorithms/cpp/patchingArray/PatchingArray.cpp)|Medium|
diff --git a/algorithms/cpp/powerOfFour/PowerOfFour.cpp b/algorithms/cpp/powerOfFour/PowerOfFour.cpp
new file mode 100644
index 000000000..f66e6d9e2
--- /dev/null
+++ b/algorithms/cpp/powerOfFour/PowerOfFour.cpp
@@ -0,0 +1,37 @@
+// Source : https://leetcode.com/problems/power-of-four/
+// Author : Hao Chen
+// Date   : 2016-05-29
+
+/*************************************************************************************** 
+ *
+ * Given an integer (signed 32 bits), write a function to check whether it is a power 
+ * of 4.
+ * 
+ * Example:
+ * Given num = 16, return true.
+ * Given num = 5, return false.
+ * 
+ * Follow up: Could you solve it without loops/recursion?
+ * 
+ * Credits:Special thanks to @yukuairoy  for adding this problem and creating all test 
+ * cases.
+ ***************************************************************************************/
+
+
+class Solution {
+public:
+    bool isPowerOfFour(int num) {
+        static int mask = 0b01010101010101010101010101010101;
+        
+        //edge case
+        if (num<=0) return false;
+        
+        // there are multiple bits are 1
+        if ((num & num-1) != 0) return false;
+        
+        // check which one bit is zero, if the place is 1 or 3 or 5 or 7 or 9...,
+        // then it is the power of 4
+        if ((num & mask) != 0) return true;
+        return false;
+    }
+};

From 35ed8b3590b0400b21d42979b2d6f224ce8e2622 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Sun, 29 May 2016 16:27:19 +0800
Subject: [PATCH 48/54] the solution of problem "Integer Break"

---
 README.md                                    |  1 +
 algorithms/cpp/integerBreak/IntegerBreak.cpp | 46 ++++++++++++++++++++
 2 files changed, 47 insertions(+)
 create mode 100644 algorithms/cpp/integerBreak/IntegerBreak.cpp

diff --git a/README.md b/README.md
index b3535e609..bc09b594d 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,7 @@ LeetCode
 |347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | [C++](./algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp)|Medium|
 |345|[Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/) | [C++](./algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp)|Easy|
 |344|[Reverse String](https://leetcode.com/problems/reverse-string/) | [C++](./algorithms/cpp/reverseString/ReverseString.cpp)|Easy|
+|343|[Integer Break](https://leetcode.com/problems/integer-break/) | [C++](./algorithms/cpp/integerBreak/IntegerBreak.cpp)|Medium|
 |342|[Power of Four](https://leetcode.com/problems/power-of-four/) | [C++](./algorithms/cpp/powerOfFour/PowerOfFour.cpp)|Easy|
 |337|[House Robber III](https://leetcode.com/problems/house-robber-iii/) | [C++](./algorithms/cpp/houseRobber/houseRobberIII.cpp)|Medium|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
diff --git a/algorithms/cpp/integerBreak/IntegerBreak.cpp b/algorithms/cpp/integerBreak/IntegerBreak.cpp
new file mode 100644
index 000000000..21f78bb82
--- /dev/null
+++ b/algorithms/cpp/integerBreak/IntegerBreak.cpp
@@ -0,0 +1,46 @@
+// Source : https://leetcode.com/problems/integer-break/
+// Author : Hao Chen
+// Date   : 2016-05-29
+
+/*************************************************************************************** 
+ *
+ * Given a positive integer n, break it into the sum of at least two positive integers 
+ * and maximize the product of those integers. Return the maximum product you can get.
+ * 
+ * For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 
+ * + 4).
+ * 
+ * Note: you may assume that n is not less than 2.
+ * 
+ *   There is a simple O(n) solution to this problem.
+ *   You may check the breaking results of n ranging from 7 to 10 to discover the 
+ * regularities.
+ * 
+ * Credits:Special thanks to @jianchao.li.fighter for adding this problem and creating 
+ * all test cases.
+ ***************************************************************************************/
+
+class Solution {
+public:
+    // As the hint said, checking the n with ranging from 7 to 10 to discover the regularities.
+    // n = 7,    3*4 = 12
+    // n = 8,  3*3*2 = 18
+    // n = 9,  3*3*3 = 27
+    // n = 10, 3*3*4 = 36
+    // n = 11, 3*3*3*2 = 54
+    //
+    // we can see we can break the number by 3 if it is greater than 4;
+    //
+    int integerBreak(int n) {
+        if ( n == 2 ) return 1;
+        if ( n == 3 ) return 2;
+        int result = 1;
+        while( n > 4 ) {
+            result *= 3;
+            n -= 3;
+        }
+        result *= n;
+        return result;
+    }
+};
+

From ecb178901cd760480b50e38961853f113e95db11 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Mon, 30 May 2016 00:42:46 +0800
Subject: [PATCH 49/54] the solution of the problem "Flatten Nested List
 Iterator"

---
 README.md                                     |  1 +
 .../FlattenNestedListIterator.cpp             | 74 +++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 algorithms/cpp/flattenNestedListIterator/FlattenNestedListIterator.cpp

diff --git a/README.md b/README.md
index bc09b594d..cb84551d3 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,7 @@ LeetCode
 |344|[Reverse String](https://leetcode.com/problems/reverse-string/) | [C++](./algorithms/cpp/reverseString/ReverseString.cpp)|Easy|
 |343|[Integer Break](https://leetcode.com/problems/integer-break/) | [C++](./algorithms/cpp/integerBreak/IntegerBreak.cpp)|Medium|
 |342|[Power of Four](https://leetcode.com/problems/power-of-four/) | [C++](./algorithms/cpp/powerOfFour/PowerOfFour.cpp)|Easy|
+|341|[Flatten Nested List Iterator](https://leetcode.com/problems/flatten-nested-list-iterator/) | [C++](./algorithms/cpp/flattenNestedListIterator/FlattenNestedListIterator.cpp)|Medium|
 |337|[House Robber III](https://leetcode.com/problems/house-robber-iii/) | [C++](./algorithms/cpp/houseRobber/houseRobberIII.cpp)|Medium|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
 |330|[Patching Array](https://leetcode.com/problems/patching-array/) | [C++](./algorithms/cpp/patchingArray/PatchingArray.cpp)|Medium|
diff --git a/algorithms/cpp/flattenNestedListIterator/FlattenNestedListIterator.cpp b/algorithms/cpp/flattenNestedListIterator/FlattenNestedListIterator.cpp
new file mode 100644
index 000000000..e62484864
--- /dev/null
+++ b/algorithms/cpp/flattenNestedListIterator/FlattenNestedListIterator.cpp
@@ -0,0 +1,74 @@
+// Source : https://leetcode.com/problems/flatten-nested-list-iterator/
+// Author : Hao Chen
+// Date   : 2016-05-30
+
+/*************************************************************************************** 
+ *
+ * Given a nested list of integers, implement an iterator to flatten it.
+ * 
+ * Each element is either an integer, or a list -- whose elements may also be integers 
+ * or other lists.
+ * 
+ * Example 1:
+ * Given the list [[1,1],2,[1,1]],
+ * 
+ * By calling next repeatedly until hasNext returns false, the order of elements 
+ * returned by next should be: [1,1,2,1,1].
+ * 
+ * Example 2:
+ * Given the list [1,[4,[6]]],
+ * 
+ * By calling next repeatedly until hasNext returns false, the order of elements 
+ * returned by next should be: [1,4,6].
+ ***************************************************************************************/
+
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * class NestedInteger {
+ *   public:
+ *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     bool isInteger() const;
+ *
+ *     // Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     // The result is undefined if this NestedInteger holds a nested list
+ *     int getInteger() const;
+ *
+ *     // Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     // The result is undefined if this NestedInteger holds a single integer
+ *     const vector<NestedInteger> &getList() const;
+ * };
+ */
+class NestedIterator {
+private:
+    vector<int> v;
+    int index;
+    void flatten(vector<NestedInteger> &nestedList) {
+        for (auto item : nestedList){
+            if (item.isInteger()){
+                v.push_back( item.getInteger() );
+            }else{
+                flatten( item.getList() );
+            }
+        }
+    }
+public:
+    NestedIterator(vector<NestedInteger> &nestedList) {
+        flatten(nestedList);
+        index = 0;
+    }
+
+    int next() {
+        return v[index++];
+    }
+
+    bool hasNext() {
+        return (index < v.size() );
+    }
+};
+
+/**
+ * Your NestedIterator object will be instantiated and called as such:
+ * NestedIterator i(nestedList);
+ * while (i.hasNext()) cout << i.next();
+ */

From eb040df04b9715b274da44e2b1e43ff8c64bb145 Mon Sep 17 00:00:00 2001
From: Hao Chen <haoel@hotmail.com>
Date: Mon, 30 May 2016 01:36:23 +0800
Subject: [PATCH 50/54] the solution of the problem "Counting Bits"

---
 README.md                                    |  1 +
 algorithms/cpp/countingBits/CountingBits.cpp | 67 ++++++++++++++++++++
 2 files changed, 68 insertions(+)
 create mode 100644 algorithms/cpp/countingBits/CountingBits.cpp

diff --git a/README.md b/README.md
index cb84551d3..cfe31bb33 100644
--- a/README.md
+++ b/README.md
@@ -16,6 +16,7 @@ LeetCode
 |343|[Integer Break](https://leetcode.com/problems/integer-break/) | [C++](./algorithms/cpp/integerBreak/IntegerBreak.cpp)|Medium|
 |342|[Power of Four](https://leetcode.com/problems/power-of-four/) | [C++](./algorithms/cpp/powerOfFour/PowerOfFour.cpp)|Easy|
 |341|[Flatten Nested List Iterator](https://leetcode.com/problems/flatten-nested-list-iterator/) | [C++](./algorithms/cpp/flattenNestedListIterator/FlattenNestedListIterator.cpp)|Medium|
+|338|[Counting Bits](https://leetcode.com/problems/counting-bits/) | [C++](./algorithms/cpp/countingBits/CountingBits.cpp)|Medium|
 |337|[House Robber III](https://leetcode.com/problems/house-robber-iii/) | [C++](./algorithms/cpp/houseRobber/houseRobberIII.cpp)|Medium|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [C++](./algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp)|Medium|
 |330|[Patching Array](https://leetcode.com/problems/patching-array/) | [C++](./algorithms/cpp/patchingArray/PatchingArray.cpp)|Medium|
diff --git a/algorithms/cpp/countingBits/CountingBits.cpp b/algorithms/cpp/countingBits/CountingBits.cpp
new file mode 100644
index 000000000..0bfe843b1
--- /dev/null
+++ b/algorithms/cpp/countingBits/CountingBits.cpp
@@ -0,0 +1,67 @@
+// Source : https://leetcode.com/problems/counting-bits/
+// Author : Hao Chen
+// Date   : 2016-05-30
+
+/*************************************************************************************** 
+ *
+ * Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ 
+ * num calculate the number of 1's in their binary representation and return them as an 
+ * array.
+ * 
+ * Example:
+ * For num = 5 you should return [0,1,1,2,1,2].
+ * 
+ * Follow up:
+ * 
+ * It is very easy to come up with a solution with run time O(n*sizeof(integer)). But 
+ * can you do it in linear time O(n) /possibly in a single pass?
+ * Space complexity should be O(n).
+ * Can you do it like a boss? Do it without using any builtin function like 
+ * __builtin_popcount  in c++ or in any other language.
+ * 
+ *   You should make use of what you have produced already.
+ *   Divide the numbers in ranges like [2-3], [4-7], [8-15] and so on. And try to 
+ * generate new range from previous.
+ *   Or does the odd/even status of the number help you in calculating the number of 1s?
+ * 
+ * Credits:Special thanks to @ syedee  for adding this problem and creating all test 
+ * cases.
+ ***************************************************************************************/
+
+class Solution {
+public:
+    /* 
+     * Initialization
+     * 
+     *   bits_cnt[0] => 0000 => 0
+     *   bits_cnt[1] => 0001 => 1
+     * 
+     * if the number has 2 bits (2, 3), then we can split the binary to two parts, 
+     * 2 = 10 + 0  and  3= 10 + 1, then we can reuse the bits_cnt[0] and bits_cnt[1] 
+     *
+     *   bits_cnt[2] => 0010 => 0010 + 0 => 1 + bits_cnt[0];
+     *   bits_cnt[3] => 0011 => 0010 + 1 => 1 + bits_cnt[1];
+     *
+     * if the number has 3 bits (4,5,6,7), then we can split the binary to two parts, 
+     * 4 = 100 + 0,  5 = 100 + 01, 6= 100 + 10, 7 = 100 +11
+     * then we can reuse the bits_cnt[0] and bits_cnt[1] 
+     * 
+     *   bits_cnt[4] => 0110 => 0100 + 00 => 1 + bits_cnt[0];
+     *   bits_cnt[5] => 0101 => 0100 + 01 => 1 + bits_cnt[1];
+     *   bits_cnt[6] => 0110 => 0100 + 10 => 1 + bits_cnt[2];
+     *   bits_cnt[7] => 0111 => 0100 + 11 => 1 + bits_cnt[3];
+     *
+     * so, we can have the solution:
+     *
+     *   bits_cnt[x] = bits_cnt[x & (x-1) ] + 1;
+     *
+     */
+    vector<int> countBits(int num) {
+        vector<int> bits_cnt(num+1, 0); 
+        
+        for (int i=1; i<=num; i++) {
+            bits_cnt[i] = bits_cnt[i & (i-1)] + 1;
+        }
+        return bits_cnt;
+    }
+};

From 94e9e4b090455ff07f6e57d8f73855654f9defb1 Mon Sep 17 00:00:00 2001
From: wuxun <wuxunyidao@gmail.com>
Date: Tue, 14 Jun 2016 20:31:43 +0800
Subject: [PATCH 51/54] fix a wrong number in comment

---
 algorithms/cpp/editDistance/editDistance.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/algorithms/cpp/editDistance/editDistance.cpp b/algorithms/cpp/editDistance/editDistance.cpp
index ec5612658..776e9661a 100644
--- a/algorithms/cpp/editDistance/editDistance.cpp
+++ b/algorithms/cpp/editDistance/editDistance.cpp
@@ -75,7 +75,7 @@ using namespace std;
  *            ""  0 1 2 3 4 5
  *            a   1 0 1 2 3 4 
  *            b   2 1 0 1 2 3
- *            b   3 2 1 1 1 2
+ *            b   3 2 1 1 2 2
  *
  */
 int min(int x, int y, int z) {

From b4e083642db5f9df15d2112cdd199759ed2d9621 Mon Sep 17 00:00:00 2001
From: arctanx <coty0@sina.com>
Date: Wed, 6 Jul 2016 23:10:13 +0800
Subject: [PATCH 52/54] Update bullsAndCows.cpp

---
 algorithms/cpp/bullsAndCows/bullsAndCows.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/algorithms/cpp/bullsAndCows/bullsAndCows.cpp b/algorithms/cpp/bullsAndCows/bullsAndCows.cpp
index f91550532..feeb1bb89 100644
--- a/algorithms/cpp/bullsAndCows/bullsAndCows.cpp
+++ b/algorithms/cpp/bullsAndCows/bullsAndCows.cpp
@@ -42,8 +42,8 @@ class Solution {
     }
 
     string getHint01(string secret, string guess) {
-        int appears_in_secret[10], appears_in_guess[10], bulls[10];
-        int total_bulls, total_cows;
+        int appears_in_secret[10] = {0}, appears_in_guess[10] = {0}, bulls[10] = {0};
+        int total_bulls = 0, total_cows = 0;
         for(int i = 0; i < secret.size(); i++)
             appears_in_secret[secret[i] - '0']++;
         for(int i = 0; i < guess.size(); i++)

From 227b5749fcf968f51d0290371b3e823c9774b1fc Mon Sep 17 00:00:00 2001
From: Vali <vally_ersaro@yahoo.com>
Date: Sun, 7 Aug 2016 16:35:33 +0300
Subject: [PATCH 53/54] added combinationSumIV

---
 README.md                                     |  1 +
 .../cpp/combinationSumIV/combinationSumIV.cpp | 68 +++++++++++++++++++
 2 files changed, 69 insertions(+)
 create mode 100644 algorithms/cpp/combinationSumIV/combinationSumIV.cpp

diff --git a/README.md b/README.md
index cfe31bb33..cfb9929c2 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|377|[Combination Sum IV](https://leetcode.com/problems/combination-sum-iv/) | [C++](./algorithms/cpp/combinationSumIV/combinationSumIV.cpp)|Medium|
 |350|[Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/) | [C++](./algorithms/cpp/intersectionOfTwoArraysII/intersectionOfTwoArraysII.cpp)|Easy|
 |349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) | [C++](./algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp)|Easy|
 |347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | [C++](./algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp)|Medium|
diff --git a/algorithms/cpp/combinationSumIV/combinationSumIV.cpp b/algorithms/cpp/combinationSumIV/combinationSumIV.cpp
new file mode 100644
index 000000000..d3006375d
--- /dev/null
+++ b/algorithms/cpp/combinationSumIV/combinationSumIV.cpp
@@ -0,0 +1,68 @@
+// Source : https://leetcode.com/problems/combination-sum-iv/
+// Author : Calinescu Valentin
+// Date   : 2016-08-07
+
+/*************************************************************************************** 
+ *
+ * Given an integer array with all positive numbers and no duplicates, find the number
+ * of possible combinations that add up to a positive integer target.
+ * 
+ * Example:
+ * 
+ * nums = [1, 2, 3]
+ * target = 4
+ * 
+ * The possible combination ways are:
+ * (1, 1, 1, 1)
+ * (1, 1, 2)
+ * (1, 2, 1)
+ * (1, 3)
+ * (2, 1, 1)
+ * (2, 2)
+ * (3, 1)
+ * 
+ * Note that different sequences are counted as different combinations.
+ * 
+ * Therefore the output is 7.
+ * Follow up:
+ * What if negative numbers are allowed in the given array?
+ * How does it change the problem?
+ * What limitation we need to add to the question to allow negative numbers?
+ * 
+ ***************************************************************************************/
+ 
+ /* Solution
+  * --------
+  * 1) Dynamic Programming - O(N *  target)
+  *
+  * We notice that any sum S can be written as S_prev + nums[i], where S_prev is a sum of
+  * elements from nums and nums[i] is one element of the array. S_prev is always smaller 
+  * than S so we can create the array sol, where sol[i] is the number of ways one can 
+  * arrange the elements of the array to obtain sum i, and populate it from 1 to target,
+  * as the solution for i is made up of previously computed ones for numbers smaller than
+  * i. The final answer is sol[target], which is returned at the end.
+  *
+  * Follow up:
+  * 
+  * If the array contains negative numbers as well as positive ones we can run into a cycle
+  * where some subset of the elements have sum 0 so they can always be added to an existing
+  * sum, leading to an infinite number of solutions. The limitation that we need is a rule
+  * to be followed by the input data, that which doesn't allow this type of subsets to exist.
+  */
+class Solution {
+public:
+    int combinationSum4(vector<int>& nums, int target) {
+        int sol[target + 1];
+        sol[0] = 1;//starting point, only 1 way to obtain 0, that is to have 0 elements
+        for(int i = 1; i <= target; i++)
+        {
+            sol[i] = 0;
+            for(int j = 0; j < nums.size(); j++)
+            {
+                if(i >= nums[j])//if there is a previously calculated sum to add nums[j] to
+                    sol[i] += sol[i - nums[j]];
+            }
+        }
+        return sol[target];
+    }
+};

From 931ba6a9a7888fdf9e16ddefa16a6d76ecb4a1e0 Mon Sep 17 00:00:00 2001
From: Vali <vally_ersaro@yahoo.com>
Date: Mon, 8 Aug 2016 11:12:28 +0300
Subject: [PATCH 54/54] added wiggleSubsequence

---
 README.md                                     |  1 +
 .../wiggleSubsequence/wiggleSubsequence.cpp   | 88 +++++++++++++++++++
 2 files changed, 89 insertions(+)
 create mode 100644 algorithms/cpp/wiggleSubsequence/wiggleSubsequence.cpp

diff --git a/README.md b/README.md
index cfb9929c2..3091c6a5c 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,7 @@ LeetCode
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
 |377|[Combination Sum IV](https://leetcode.com/problems/combination-sum-iv/) | [C++](./algorithms/cpp/combinationSumIV/combinationSumIV.cpp)|Medium|
+|376|[Wiggle Subsequence](https://leetcode.com/problems/wiggle-subsequence/) | [C++](./algorithms/cpp/wiggleSubsequence/wiggleSubsequence.cpp)|Medium|
 |350|[Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/) | [C++](./algorithms/cpp/intersectionOfTwoArraysII/intersectionOfTwoArraysII.cpp)|Easy|
 |349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) | [C++](./algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp)|Easy|
 |347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | [C++](./algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp)|Medium|
diff --git a/algorithms/cpp/wiggleSubsequence/wiggleSubsequence.cpp b/algorithms/cpp/wiggleSubsequence/wiggleSubsequence.cpp
new file mode 100644
index 000000000..5631e5713
--- /dev/null
+++ b/algorithms/cpp/wiggleSubsequence/wiggleSubsequence.cpp
@@ -0,0 +1,88 @@
+// Source : https://leetcode.com/problems/wiggle-subsequence/
+// Author : Calinescu Valentin
+// Date   : 2016-08-08
+
+/*************************************************************************************** 
+ *
+ * A sequence of numbers is called a wiggle sequence if the differences between
+ * successive numbers strictly alternate between positive and negative. The first
+ * difference (if one exists) may be either positive or negative. A sequence with fewer
+ * than two elements is trivially a wiggle sequence.
+ * 
+ * For example, [1,7,4,9,2,5] is a wiggle sequence because the differences (6,-3,5,-7,3)
+ * are alternately positive and negative. In contrast, [1,4,7,2,5] and [1,7,4,5,5] are
+ * not wiggle sequences, the first because its first two differences are positive and
+ * the second because its last difference is zero.
+ * 
+ * Given a sequence of integers, return the length of the longest subsequence that is a
+ * wiggle sequence. A subsequence is obtained by deleting some number of elements
+ * (eventually, also zero) from the original sequence, leaving the remaining elements in
+ * their original order.
+ * 
+ * Examples:
+ * Input: [1,7,4,9,2,5]
+ * Output: 6
+ * The entire sequence is a wiggle sequence.
+ * 
+ * Input: [1,17,5,10,13,15,10,5,16,8]
+ * Output: 7
+ * There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8].
+ * 
+ * Input: [1,2,3,4,5,6,7,8,9]
+ * Output: 2
+ * 
+ * Follow up:
+ * Can you do it in O(n) time?
+ * 
+ ***************************************************************************************/
+ 
+ /* Solution
+  * --------
+  * 1) O(N)
+  * 
+  * We notice that adding a new number to an existing subsequence means finding one that
+  * is smaller or bigger than the previous number, according to the difference between the
+  * previous number and the number before that as we always need to alternate between increasing
+  * and decreasing subsequences. If we encounter increasing or decreasing sequences of 2 or 
+  * more consecutive numbers we can treat the entire subsequence as a number, because that way 
+  * we can always be sure we don't miss any solution, as finding a number smaller than any 
+  * number of an increasing subsequence is guaranteed to be smaller than the biggest number 
+  * in the subsequence. Thus, we can only check the difference between consecutive numbers.
+  * 
+  * Follow up:
+  * 
+  * The time complexity is already O(N).
+  */
+class Solution {
+public:
+    int wiggleMaxLength(vector<int>& nums) {
+        int solution = 0;//if we have an empty vector the solution is 0
+        if(nums.size())
+        {
+            solution = 1;
+            int bigger = 0;//0 is the starting point to be followed by either an increasing or decreasing sequence
+            for(int i = 1; i < nums.size(); i++)
+            {
+                if(nums[i] == nums[i - 1])
+                    continue;//we can ignore duplicates as they can always be omitted
+                else if(nums[i] > nums[i - 1])
+                {
+                    if(bigger == 0 || bigger == 2)
+                    {
+                        bigger = 1;//1 means we now have an increasing sequence
+                        solution++;
+                    }
+                }
+                else //if(nums[i] < nums[i - 1])
+                {
+                    if(bigger == 0 || bigger == 1)
+                    {
+                        bigger = 2;//2 means we now have a decreasing sequence
+                        solution++;
+                    }
+                }
+            }
+        }
+        return solution;
+    }
+};

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://github.com/haoel/leetcode/compare/master...rtu:leetcode:master.patch" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://github.com/haoel/leetcode/compare/master...rtu:leetcode:master.patch" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://github.com/haoel/leetcode/compare/master...rtu:leetcode:master.patch" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://github.com/haoel/leetcode/compare/master...rtu:leetcode:master.patch" target="_blank">pFad v4 Proxy</a></p></body>
</html>