add the problem content into source file

Author: haoel

src/3Sum/3Sum.cpp

@@ -2,6 +2,24 @@
 // Author : Hao Chen
 // Date   : 2014-07-22
 
+/********************************************************************************** 
+* 
+* Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
+* 
+* Note:
+* 
+* Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
+* The solution set must not contain duplicate triplets.
+* 
+*     For example, given array S = {-1 0 1 2 -1 -4},
+* 
+*     A solution set is:
+*     (-1, 0, 1)
+*     (-1, -1, 2)
+* 
+*               
+**********************************************************************************/
+
 #include <stdio.h>
 #include <iostream>
 #include <vector>

src/3SumClosest/3SumClosest.cpp

@@ -2,6 +2,17 @@
 // Author : Hao Chen
 // Date   : 2014-07-03
 
+/********************************************************************************** 
+* 
+* Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.
+* 
+*     For example, given array S = {-1 2 1 -4}, and target = 1.
+* 
+*     The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+* 
+*               
+**********************************************************************************/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <iostream>

src/4Sum/4Sum.cpp

@@ -2,6 +2,25 @@
 // Author : Hao Chen
 // Date   : 2014-07-03
 
+/********************************************************************************** 
+* 
+* Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.
+* 
+* Note:
+* 
+* Elements in a quadruplet (a,b,c,d) must be in non-descending order. (ie, a ≤ b ≤ c ≤ d)
+* The solution set must not contain duplicate quadruplets.
+* 
+*     For example, given array S = {1 0 -1 0 -2 2}, and target = 0.
+* 
+*     A solution set is:
+*     (-1,  0, 0, 1)
+*     (-2, -1, 1, 2)
+*     (-2,  0, 0, 2)
+* 
+*               
+**********************************************************************************/
+
 #include <iostream>
 #include <vector>
 #include <algorithm>

src/LRUCache/LRUCache.cpp

@@ -2,6 +2,16 @@
 // Author : Hao Chen
 // Date   : 2014-10-12
 
+/********************************************************************************** 
+* 
+* Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.
+* 
+* get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
+* set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.
+* 
+*               
+**********************************************************************************/
+
 #include <stdlib.h>
 #include <time.h>
 #include <iostream>

src/addBinary/addBinary.cpp

@@ -2,6 +2,18 @@
 // Author : Hao Chen
 // Date   : 2014-07-05
 
+/********************************************************************************** 
+* 
+* Given two binary strings, return their sum (also a binary string).
+* 
+* For example,
+* a = "11"
+* b = "1"
+* Return "100".
+* 
+*               
+**********************************************************************************/
+
 #include <iostream>
 #include <string>
 using namespace std;

src/addTwoNumbers/addTwoNumbers.cpp

@@ -2,6 +2,15 @@
 // Author : Hao Chen
 // Date   : 2014-06-18
 
+/********************************************************************************** 
+* 
+* You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
+* 
+* Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+* Output: 7 -> 0 -> 8
+*               
+**********************************************************************************/
+
 /**
  * Definition for singly-linked list.
  * struct ListNode {

src/anagrams/anagrams.cpp

@@ -2,6 +2,14 @@
 // Author : Hao Chen
 // Date   : 2014-07-18
 
+/********************************************************************************** 
+* 
+* Given an array of strings, return all groups of strings that are anagrams.
+* 
+* Note: All inputs will be in lower-case.
+*               
+**********************************************************************************/
+
 class Solution {
 public:
     vector<string> anagrams(vector<string> &strs) {

src/balancedBinaryTree/balancedBinaryTree.cpp

@@ -2,6 +2,15 @@
 // Author : Hao Chen
 // Date   : 2014-06-28
 
+/********************************************************************************** 
+* 
+* Given a binary tree, determine if it is height-balanced.
+* 
+* For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
+* 
+*               
+**********************************************************************************/
+
 /**
  * Definition for binary tree
  * struct TreeNode {

src/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.II.cpp

@@ -2,6 +2,14 @@
 // Author : Hao Chen
 // Date   : 2014-06-18
 
+/********************************************************************************** 
+* 
+* Say you have an array for which the ith element is the price of a given stock on day i.
+* 
+* Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+*               
+**********************************************************************************/
+
 class Solution {
 public:
     int maxProfit(vector<int> &prices) {

src/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.III.cpp

@@ -2,6 +2,17 @@
 // Author : Hao Chen
 // Date   : 2014-08-22
 
+/********************************************************************************** 
+* 
+* Say you have an array for which the ith element is the price of a given stock on day i.
+* 
+* Design an algorithm to find the maximum profit. You may complete at most two transactions.
+* 
+* Note:
+* You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+*               
+**********************************************************************************/
+
 
 class Solution {
 public:

src/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.cpp

@@ -2,6 +2,14 @@
 // Author : Hao Chen
 // Date   : 2014-06-18
 
+/********************************************************************************** 
+* 
+* Say you have an array for which the ith element is the price of a given stock on day i.
+* 
+* If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
+*               
+**********************************************************************************/
+
 class Solution {
 public:
     int maxProfit(vector<int> &prices) {

src/binaryTreeInorderTraversal/binaryTreeInorderTraversal.cpp

@@ -2,6 +2,44 @@
 // Author : Hao Chen
 // Date   : 2014-06-27
 
+/********************************************************************************** 
+* 
+* Given a binary tree, return the inorder traversal of its nodes' values.
+* 
+* For example:
+* Given binary tree {1,#,2,3},
+* 
+*    1
+*     \
+*      2
+*     /
+*    3
+* 
+* return [1,3,2].
+* 
+* Note: Recursive solution is trivial, could you do it iteratively?
+* 
+* confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.
+* 
+* OJ's Binary Tree Serialization:
+* 
+* The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.
+* 
+* Here's an example:
+* 
+*    1
+*   / \
+*  2   3
+*     /
+*    4
+*     \
+*      5
+* 
+* The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}". 
+* 
+*               
+**********************************************************************************/
+
 /**
  * Definition for binary tree
  * struct TreeNode {

src/binaryTreeLevelOrderTraversal/binaryTreeLevelOrderTraversal.II.cpp

@@ -2,6 +2,48 @@
 // Author : Hao Chen
 // Date   : 2014-06-27
 
+/********************************************************************************** 
+* 
+* Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).
+* 
+* For example:
+* Given binary tree {3,9,20,#,#,15,7},
+* 
+*     3
+*    / \
+*   9  20
+*     /  \
+*    15   7
+* 
+* return its bottom-up level order traversal as:
+* 
+* [
+*   [15,7],
+*   [9,20],
+*   [3]
+* ]
+* 
+* confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.
+* 
+* OJ's Binary Tree Serialization:
+* 
+* The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.
+* 
+* Here's an example:
+* 
+*    1
+*   / \
+*  2   3
+*     /
+*    4
+*     \
+*      5
+* 
+* The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}". 
+* 
+*               
+**********************************************************************************/
+
 /**
  * Definition for binary tree
  * struct TreeNode {

src/binaryTreeLevelOrderTraversal/binaryTreeLevelOrderTraversal.cpp

@@ -2,6 +2,48 @@
 // Author : Hao Chen
 // Date   : 2014-07-17
 
+/********************************************************************************** 
+* 
+* Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).
+* 
+* For example:
+* Given binary tree {3,9,20,#,#,15,7},
+* 
+*     3
+*    / \
+*   9  20
+*     /  \
+*    15   7
+* 
+* return its level order traversal as:
+* 
+* [
+*   [3],
+*   [9,20],
+*   [15,7]
+* ]
+* 
+* confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.
+* 
+* OJ's Binary Tree Serialization:
+* 
+* The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.
+* 
+* Here's an example:
+* 
+*    1
+*   / \
+*  2   3
+*     /
+*    4
+*     \
+*      5
+* 
+* The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}". 
+* 
+*               
+**********************************************************************************/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>

src/binaryTreeMaximumPathSum/binaryTreeMaximumPathSum.cpp

@@ -2,6 +2,24 @@
 // Author : Hao Chen
 // Date   : 2014-10-10
 
+/********************************************************************************** 
+* 
+* Given a binary tree, find the maximum path sum.
+* 
+* The path may start and end at any node in the tree.
+* 
+* For example:
+* Given the below binary tree,
+* 
+*        1
+*       / \
+*      2   3
+* 
+* Return 6.
+* 
+*               
+**********************************************************************************/
+
 #include <iostream>
 #include <algorithm>
 using namespace std;

src/binaryTreePostorderTraversal/binaryTreePostorderTraversal.cpp

@@ -2,6 +2,25 @@
 // Author : Hao Chen
 // Date   : 2014-07-21
 
+/********************************************************************************** 
+* 
+* Given a binary tree, return the postorder traversal of its nodes' values.
+* 
+* For example:
+* Given binary tree {1,#,2,3},
+* 
+*    1
+*     \
+*      2
+*     /
+*    3
+* 
+* return [3,2,1].
+* 
+* Note: Recursive solution is trivial, could you do it iteratively?
+*               
+**********************************************************************************/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>