Add comments to explain the solutions

haoel · haoel · commit 540738b55bfd · 2014-10-27T22:43:09.000+08:00
diff --git a/src/editDistance/editDistance.cpp b/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;
             }
         }
diff --git a/src/firstMissingPositive/firstMissingPositive.cpp b/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));
         }
diff --git a/src/insertInterval/insertInterval.cpp b/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);
diff --git a/src/jumpGame/jumpGame.II.cpp b/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;
 }
diff --git a/src/jumpGame/jumpGame.cpp b/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){
diff --git a/src/mergeIntervals/mergeIntervals.cpp b/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{
diff --git a/src/nQueens/nQueuens.II.cpp b/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++) {
diff --git a/src/nQueens/nQueuens.cpp b/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++) {
diff --git a/src/permutations/permutations.II.cpp b/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;
diff --git a/src/permutations/permutations.cpp b/src/permutations/permutations.cpp
@@ -28,6 +28,37 @@ using namespace std;
 { 3 1 2 }
 */
 
+/*
+ *    The algroithm - Take each element in array to the first place.
+ *
+ *    For example: 
+ *    
+ *         0) initalization 
+ * 
+ *             pos = 0
+ *             [1, 2, 3]   
+ *
+ *         1) take each element into the first place, 
+ *
+ *             pos = 1
+ *             [1, 2, 3]  ==>  [2, 1, 3] , [3, 1, 2] 
+ *
+ *             then we have total 3 answers
+ *             [1, 2, 3],  [2, 1, 3] , [3, 1, 2] 
+ *            
+ *         2) take each element into the "first place" -- pos 
+ *
+ *             pos = 2
+ *             [1, 2, 3]  ==>  [1, 3, 2]
+ *             [2, 1, 3]  ==>  [2, 3, 1]
+ *             [3, 1, 2]  ==>  [3, 2, 1] 
+ *
+ *             then we have total 6 answers
+ *             [1, 2, 3],  [2, 1, 3] , [3, 1, 2], [1, 3, 2], [2, 3, 1], [3, 2, 1]
+ *
+ *          3) pos = 3 which greater than length of array, return.
+ *
+ */
 vector<vector<int> > permute(vector<int> &num) {
     
     vector<vector<int> > vv;
@@ -41,7 +72,7 @@ vector<vector<int> > permute(vector<int> &num) {
     while(pos<num.size()-1){
         int size = vv.size();
         for(int i=0; i<size; i++){
-            //take each number to the first
+            //take each number to the first place
             for (int j=pos+1; j<vv[i].size(); j++) {
                 vector<int> v = vv[i];
                 int t = v[j]; 
diff --git a/src/searchInRotatedSortedArray/searchInRotatedSortedArray.II.cpp b/src/searchInRotatedSortedArray/searchInRotatedSortedArray.II.cpp
@@ -13,6 +13,16 @@
 *               
 **********************************************************************************/
 
+// Using the same idea "Search in Rotated Sorted Array"
+// but need be very careful about the following cases:
+//   [3,3,3,4,5,6,3,3] 
+//   [3,3,3,3,1,3]
+// After split, you don't know which part is rotated and which part is not.
+// So, you have to skip the ducplication
+//   [3,3,3,4,5,6,3,3] 
+//          ^       ^
+//   [3,3,3,3,1,3]
+//            ^ ^
 class Solution {
 public:
     bool search(int A[], int n, int key) {
@@ -28,8 +38,7 @@ class Solution {
                  return false;
             }
             
-            //if dupilicates, them binary search the duplication
-            
+            //if dupilicates, remove the duplication
             while (low < high && A[low]==A[high]){
                 low++;
             }
diff --git a/src/searchInRotatedSortedArray/searchInRotatedSortedArray.cpp b/src/searchInRotatedSortedArray/searchInRotatedSortedArray.cpp
diff --git a/src/trappingRainWater/trappingRainWater.cpp b/src/trappingRainWater/trappingRainWater.cpp
diff --git a/src/wildcardMatching/wildcardMatching.cpp b/src/wildcardMatching/wildcardMatching.cpp

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ int totalNQueens(int n) {`
`31`	`31`	`return result;`
`32`	`32`	`}`
`33`	`33`
`34`		`-`
	`34`	`+// the solution is same as the "N Queens" problem.`
`35`	`35`	`void solveNQueensRecursive(int n, int currentRow, vector<int>& solution, int& result) {`
`36`	`36`
`37`	`37`	`for (int i = 0; i < n; i++) {`