diff --git a/.gitignore b/.gitignore
index 1f1c65c40..25a4d2a65 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 .idea
 algorithms-java/out
+*.class
diff --git a/README.md b/README.md
index 3f71fe9be..539f6b37d 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,8 @@ 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|
 |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);
+    }
+};
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;
+    }
+};