Add comments to explain the solutions

Author: haoel

src/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.II.cpp

@@ -15,6 +15,10 @@
 
 class Solution {
 public:
+    //
+    // find all of ranges: which start a valley with the nearest peak after
+    // add their delta together 
+    //
     int maxProfit(vector<int> &prices) {
         int max=0, begin=0, end=0;
         bool up=false, down=false;
@@ -32,7 +36,7 @@ class Solution {
                 max += (prices[end] - prices[begin]);
             }
         }
-        
+        // edge case 
         if (begin < prices.size() && up==true){
             end = prices.size() - 1;
             max += (prices[end] - prices[begin]);

src/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.III.cpp

@@ -16,6 +16,18 @@
 
 class Solution {
 public:
+    // Dynamic Programming
+    //
+    //     Considering prices[n], and we have a position "i", we could have
+    //       1) the maxProfit1 for prices[0..i]  
+    //       2) the maxProfit2 for proices[i..n]
+    //
+    //    So, 
+    //      for 1) we can go through the prices[n] forwardly.
+    //          forward[i] = max( forward[i-1], price[i] - lowestPrice[0..i] ) 
+    //      for 2) we can go through the prices[n] backwoardly.
+    //          backward[i] = max( backward[i+1], highestPrice[i..n] - price[i]) 
+    //
     int maxProfit(vector<int> &prices) {
         if (prices.size()<=1) return 0;
 

src/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.cpp

@@ -13,6 +13,19 @@
 
 class Solution {
 public:
+    //
+    // This solution is O(1) space dynamic programming 
+    //
+    // We can make sure the max profit at least be ZERO. So,
+    //    1) we have two pointers (begin & end ) 
+    //    2) if prices[end] - prices[begin] >  0, then move the "end" pointer to next
+    //    3) if prices[end] - prices[begin] <= 0, then move the "begin" pointer to current posstion.
+    //    4) tracking the max profit
+    //
+    // Notes:
+    //    Some people think find the highest-price & lowest-price, this is wrong. 
+    //    Because the highest-price must be after lowest-price
+    //
     int maxProfit(vector<int> &prices) {
 
         int max=0, begin=0, end=0, delta=0;

src/binaryTreeMaximumPathSum/binaryTreeMaximumPathSum.cpp

@@ -32,18 +32,24 @@ struct TreeNode {
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };
 
-
+//The solution is quite simple can be explained by itself
 int maxPathSum(TreeNode *root, int& maxSum ) {
 
     if (NULL == root) return 0;
 
-    int val = root->val;
-    int left = root->left ? maxPathSum(root->left, maxSum) : 0;
-    int right = root->right ? maxPathSum(root->right, maxSum) : 0;
-
-    int maxBranch = left + val > right + val ?
-        max(left + val, val) : max(right + val, val);
+    //get the maxPathSum for both left and right branch
+    int left  = maxPathSum(root->left,  maxSum);
+    int right = maxPathSum(root->right, maxSum);
 
+    // The max sum could be one of the following situations:
+    //    1) root + left
+    //    2) root + right
+    //    3) root
+    //    4) root + left + right   
+    //
+    // And the whole function need to return the the max of 1) 2) 3) 
+    int val = root->val;
+    int maxBranch = left > right ? max(left + val, val) : max(right + val, val);
     int m = max(left + right + val, maxBranch);
 
     maxSum = max(maxSum, m);