Add comments to explain the solutions

Author: haoel

src/editDistance/editDistance.cpp

@@ -22,29 +22,87 @@
 #include <algorithm>
 using namespace std;
 
+
+/*
+ *  Dynamic Programming
+ *
+ *    Definitaion
+ *
+ *        m[i][j] is minimal distance from word1[0..i] to word2[0..j]
+ *
+ *    So, 
+ *
+ *        1) if word1[i] == word2[j], then m[i][j] == m[i-1][j-1].
+ *
+ *        2) if word1[i] != word2[j], then we need to find which one below is minimal:
+ *
+ *             min( m[i-1][j-1], m[i-1][j],  m[i][j-1] )
+ *            
+ *             and +1 - current char need be changed.
+ *
+ *        Let's take a look  m[1][2] :  "a" => "ab" 
+ *
+ *               +---+  +---+                                         
+ *        ''=> a | 1 |  | 2 | '' => ab                                
+ *               +---+  +---+                                         
+ *                                                                    
+ *               +---+  +---+                                         
+ *        a => a | 0 |  | 1 | a => ab                                 
+ *               +---+  +---+                                         
+ *                                                            
+ *        To know the minimal distance `a => ab`, we can get it from one of the following cases:
+ *
+ *            1) delete the last char in word1,  minDistance( '' => ab ) + 1                                                             
+ *            2) delete the last char in word2,  minDistance(  a => a ) + 1                                                             
+ *            3) change the last char,           minDistance( '' => a ) + 1                                                             
+ *                                                            
+ *  
+ *    For Example:
+ *
+ *        word1="abb", word2="abccb"
+ *
+ *        1) Initialize the DP matrix as below:
+ *
+ *               "" a b c c b
+ *            "" 0  1 2 3 4 5
+ *            a  1
+ *            b  2
+ *            b  3
+ *
+ *        2) Dynamic Programming
+ *
+ *               "" a b c c b
+ *            ""  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
+ *
+ */
+int min(int x, int y, int z) {
+    return std::min(x, std::min(y,z));
+}
+
 int minDistance(string word1, string word2) {
     int n1 = word1.size();     
     int n2 = word2.size();     
     if (n1==0) return n2;
     if (n2==0) return n1;
-    vector< vector<int> > m(n1+1);
+    vector< vector<int> > m(n1+1, vector<int>(n2+1));
     for(int i=0; i<m.size(); i++){
-        vector<int> r(n2+1);
-        r[0] = i;
-        m[i] = r;
+        m[i][0] = i;
     }
     for (int i=0; i<m[0].size(); i++) {
         m[0][i]=i;
     }
 
     //Dynamic Programming
+    int row, col;
     for (row=1; row<m.size(); row++) {
         for(col=1; col<m[row].size(); col++){
             if (word1[row-1] == word2[col-1] ){
                 m[row][col] = m[row-1][col-1];
             }else{
-                int minValue = min(m[row-1][col-1], m[row-1][col]);
-                minValue = min(minValue, m[row][col-1]);
+                int minValue = min(m[row-1][col-1], m[row-1][col],  m[row][col-1]);
                 m[row][col] = minValue + 1;
             }
         }

src/firstMissingPositive/firstMissingPositive.cpp

@@ -21,6 +21,22 @@ using namespace std;
 
 #define INT_MAX      2147483647
 
+/*
+ *    The idea is simple:
+ *
+ *    1) put all of number into a map.
+ *    2) for each number a[i] in array, remove its continous number in the map
+ *        2.1)  remove ... a[i]-3, a[i]-2, a[i]-1, a[i]
+ *        2.2)  remove a[i]+1, a[i]+2, a[i]+3,...
+ *    3) during the removeing process, if some number cannot be found, which means it's missed.
+ *
+ *    considering a case [-2, -1, 4,5,6], 
+ *        [-2, -1] => missed 0
+ *        [4,5,6]  => missed 3
+ *
+ *    However, we missed 1, so, we have to add dummy number 0 whatever.
+ *
+ */
 int firstMissingPositive(int A[], int n) {
     map<int, int> cache;
     for(int i=0; i<n; i++){
@@ -47,12 +63,14 @@ int firstMissingPositive(int A[], int n) {
         }
 
         int num ;
+        // remove the ... x-3, x-2, x-1, x
         for( num=x; cache.find(num)!=cache.end(); num--){
             cache.erase(cache.find(num));
         }
         if ( num>0 && num < miss  ){
             miss = num;
         }
+        // remove the x+1, x+2, x+3 ...
         for ( num=x+1; cache.find(num)!=cache.end(); num++){
             cache.erase(cache.find(num));
         }

src/insertInterval/insertInterval.cpp

@@ -31,6 +31,7 @@ struct Interval {
     Interval(int s, int e) : start(s), end(e) {}
 };
 
+//Two factors sorting [start:end]
 bool compare(const Interval& lhs, const Interval& rhs){
     return (lhs.start==rhs.start) ? lhs.end < rhs.end : lhs.start < rhs.start;
 }
@@ -40,10 +41,12 @@ vector<Interval> merge(vector<Interval> &intervals) {
     vector<Interval> result;
 
     if (intervals.size() <= 0) return result;
-
+    //sort the inervals. Note: using the customized comparing function.
     sort(intervals.begin(), intervals.end(), compare);
     for(int i=0; i<intervals.size(); i++) {
         int size = result.size();
+        // if the current intervals[i] is overlapped with previous interval.
+        // merge them together
         if( size>0 && result[size-1].end >= intervals[i].start) {
             result[size-1].end = max(result[size-1].end, intervals[i].end);
         }else{
@@ -54,6 +57,7 @@ vector<Interval> merge(vector<Interval> &intervals) {
     return result;
 }
 
+//just reuse the solution of "Merge Intervals", quite straight forward
 vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
 
     intervals.push_back(newInterval);

src/jumpGame/jumpGame.II.cpp

@@ -22,6 +22,7 @@
 #include <iostream>
 using namespace std;
 
+//Acutally, using the Greedy algorithm can have the answer
 int jump(int A[], int n) {
     if (n<=1) return 0;
 
@@ -36,9 +37,10 @@ int jump(int A[], int n) {
         if (coverPos >= n-1){
             return steps;
         }
+        //Greedy: find the next place which can have biggest distance
         int nextPos=0;
         int maxDistance=0;
-        for(int j=i+1; j<=A[i]+i; j++){
+        for(int j=i+1; j<=coverPos; j++){
             if ( A[j]+j > maxDistance ) {
                 maxDistance = A[j]+j;
                 nextPos = j;
@@ -59,7 +61,7 @@ void printArray(int a[], int n){
 }
 int main()
 {
-    #define TEST(a) printArray(a, sizeof(a)/sizeof(int)); cout<<jump(a, sizeof(a)/sizeof(int))<<endl;
+    #define TEST(a) printArray(a, sizeof(a)/sizeof(a[0])); cout<<jump(a, sizeof(a)/sizeof(a[0]))<<endl;
 
     int a1[]={0};
     TEST(a1);
@@ -76,5 +78,13 @@ int main()
     int a5[]={1,2,3};
     TEST(a5);
 
+    // 0 -> 1 -> 4 -> end
+    int a6[]={2,3,1,1,4,0,1};
+    TEST(a6);
+
+    // 0 -> 1 -> 3 -> end
+    int a7[]={2,3,1,2,0,1};
+    TEST(a7);
+
     return 0;
 }

src/jumpGame/jumpGame.cpp

@@ -23,7 +23,9 @@ class Solution {
     bool canJump(int A[], int n) {
         if (n<=0) return false;
 
+        // the basic idea is traverse array, maintain the most far can go
         int coverPos=0;
+        // the condition i<=coverPos means traverse all of covered position 
         for(int i=0; i<=coverPos && i<n; i++){
 
             if (coverPos < A[i] + i){

src/medianOfTwoSortedArrays/medianOfTwoSortedArrays.cpp

@@ -11,6 +11,8 @@
 
 #include <stdio.h>
 
+// Classical binary search algorithm, but slightly different
+// if cannot find the key, return the position where can insert the key 
 int binarySearch(int A[], int low, int high, int key){
     while(low<=high){
         int mid = low + (high - low)/2;
@@ -24,17 +26,33 @@ int binarySearch(int A[], int low, int high, int key){
     return low;
 }
 
+//Notes:
+// I feel the following methods is quite complicated, it should have a better high clear and readable solution
 double findMedianSortedArrayHelper(int A[], int m, int B[], int n, int lowA, int highA, int lowB, int highB) {
 
+    // Take the A[middle], search its position in B array
     int mid = lowA + (highA - lowA)/2;
     int pos = binarySearch(B, lowB, highB, A[mid]);
     int num = mid + pos;
+    // If the A[middle] in B is B's middle place, then we can have the result
     if (num == (m+n)/2){
+        // If two arrays total length is odd, just simply return the A[mid]
+        // Why not return the B[pos] instead ? 
+        //   suppose A={ 1,3,5 } B={ 2,4 }, then mid=1, pos=1
+        //   suppose A={ 3,5 }   B={1,2,4}, then mid=0, pos=2
+        //   suppose A={ 1,3,4,5 }   B={2}, then mid=1, pos=1
+        // You can see, the `pos` is the place A[mid] can be inserted, so return A[mid]
         if ((m+n)%2==1){
             return A[mid];
         }
+        
+        // If tow arrys total length is even, then we have to find the next one.
         int next;
 
+        // If both `mid` and `pos` are not the first postion.
+        // Then, find max(A[mid-1], B[pos-1]). 
+        // Because the `mid` is the second middle number, we need to find the first middle number
+        // Be careful about the edge case
         if (mid>0 && pos>0){ 
             next = A[mid-1]>B[pos-1] ? A[mid-1] : B[pos-1];
         }else if(pos>0){
@@ -45,14 +63,23 @@ double findMedianSortedArrayHelper(int A[], int m, int B[], int n, int lowA, int
 
         return (A[mid] + next)/2.0;
     }
+    // if A[mid] is in the left middle place of the whole two arrays
+    //
+    //         A(len=16)        B(len=10)
+    //     [................] [...........]
+    //            ^             ^
+    //           mid=7         pos=1
+    //
+    //  move the `low` pointer to the "middle" position, do next iteration.
     if (num < (m+n)/2){
         lowA = mid + 1;
-        lowB = pos;
+        lowB = pos; 
         if ( highA - lowA > highB - lowB ) {
             return findMedianSortedArrayHelper(A, m, B, n, lowA, highA, lowB, highB);
         }
         return findMedianSortedArrayHelper(B, n, A, m, lowB, highB, lowA, highA);
     }
+    // if A[mid] is in the right middle place of the whole two arrays
     if (num > (m+n)/2) {
         highA = mid - 1;
         highB = pos-1;
@@ -65,11 +92,17 @@ double findMedianSortedArrayHelper(int A[], int m, int B[], int n, int lowA, int
 }
 
 double findMedianSortedArrays(int A[], int m, int B[], int n) {
+
+    //checking the edge cases
     if ( m==0 && n==0 ) return 0.0;
+
+    //if the length of array is odd, return the middle one
+    //if the length of array is even, return the average of the middle two numbers
     if ( m==0 ) return n%2==1 ? B[n/2] : (B[n/2-1] + B[n/2])/2.0;
     if ( n==0 ) return m%2==1 ? A[m/2] : (A[m/2-1] + A[m/2])/2.0;
 
 
+    //let the longer array be A, and the shoter array be B
     if ( m > n ){
         return findMedianSortedArrayHelper(A, m, B, n, 0, m-1, 0, n-1);
     }

src/mergeIntervals/mergeIntervals.cpp

@@ -25,6 +25,7 @@ struct Interval {
     Interval(int s, int e) : start(s), end(e) {}
 };
 
+//Two factos sorting [start:end]
 bool compare(const Interval& lhs, const Interval& rhs){
     return (lhs.start==rhs.start) ? lhs.end < rhs.end : lhs.start < rhs.start;
 }
@@ -34,10 +35,12 @@ vector<Interval> merge(vector<Interval> &intervals) {
     vector<Interval> result;
 
     if (intervals.size() <= 0) return result;
-
+    //sort the inervals. Note: using the customized comparing function.
     sort(intervals.begin(), intervals.end(), compare);
     for(int i=0; i<intervals.size(); i++) { 
         int size = result.size();
+        // if the current intervals[i] is overlapped with previous interval.
+        // merge them together
         if( size>0 && result[size-1].end >= intervals[i].start) {
             result[size-1].end = max(result[size-1].end, intervals[i].end); 
         }else{

src/nQueens/nQueuens.II.cpp

@@ -31,7 +31,7 @@ int totalNQueens(int n) {
     return result;    
 }
 
-
+// the solution is same as the "N Queens" problem.
 void solveNQueensRecursive(int n, int currentRow, vector<int>& solution, int& result) {
 
     for (int i = 0; i < n; i++) {

src/nQueens/nQueuens.cpp

@@ -50,34 +50,40 @@ vector< vector<string> > solveNQueens(int n) {
     return result;    
 }
 
-
+//The following recursion is easy to understand. Nothing's tricky.
+//  1) recursively find all of possible columns row by row.
+//  2) solution[] array only stores the columns index. `solution[row] = col;` 
 void solveNQueensRecursive(int n, int currentRow, vector<int>& solution, vector< vector<string> >& result) {
+    //if no more row need to do, shape the result
     if (currentRow == n){
         vector<string> s;
-        for (int i = 0; i < n; i++) {
-            string row;
-            for (int j = 0; j < n; j++) {
-                if ( solution[i]== j ) {
-                    row += "Q";
-                }else{
-                    row += ".";
-                }
+        for (int row = 0; row < n; row++) {
+            string sRow;
+            for (int col = 0; col < n; col++) {
+                sRow = sRow + (solution[row] == col ? "Q" :"." );
             }
-            s.push_back(row);
+            s.push_back(sRow);
         }
         result.push_back(s);
         return;
     }
 
-    for (int i = 0; i < n; i++) {
-        if (isValid(i, currentRow, solution) ) {
-            solution[currentRow] = i;
+    //for each column
+    for (int col = 0; col < n; col++) {
+        //if the current column is valid
+        if (isValid(col, currentRow, solution) ) {
+            //place the Queue
+            solution[currentRow] = col;
+            //recursively put the Queen in next row
             solveNQueensRecursive(n, currentRow+1, solution, result);
         }
     } 
 }
 
-
+//Attempting to put the Queen into [row, col], check it is valid or not
+//Notes: 
+//  1) we just checking the Column not Row, because the row cannot be conflicted
+//  2) to check the diagonal, we just check |x'-x| == |y'-y|, (x',y') is a Queen will be placed
 bool isValid(int attemptedColumn, int attemptedRow, vector<int> &queenInColumn) {
 
     for(int i=0; i<attemptedRow; i++) {

src/permutations/permutations.II.cpp

@@ -21,6 +21,9 @@
 #include <algorithm>
 using namespace std;
 
+// To deal with the duplication number, we need do those modifications:
+//    1) sort the array [pos..n].
+//    2) skip the same number.
 vector<vector<int> > permute(vector<int> &num) {
 
     vector<vector<int> > vv;