kill process solved and readme generator bug fixed

Author: kaidul

README.md

@@ -1,10 +1,12 @@
+#include <algorithm>
 #include <cstdio>
 #include <cstdlib>
 #include <fstream>
 #include <string>
 #include <cstring>
 #include <cassert>
 #include <dirent.h>
+#include<vector>
 using namespace std;
 
 int main(void) {
@@ -13,8 +15,8 @@ int main(void) {
     DIR *dir;
     const char *directoryPath = "/Users/kaidul/LeetCode_problems_solution/source-code/";
     struct dirent *ent;
-    int serialNo = 0;
     if ((dir = opendir (directoryPath)) != NULL) {
+	vector<string> listItems;
         while ((ent = readdir (dir)) != NULL) {
             int n = strlen(ent->d_name);
             if(n < 5) { // skip hidden files
@@ -35,8 +37,15 @@ int main(void) {
             int dot = sFileName.find('.');
             assert(dot != string::npos);
             sFileName = sFileName.substr(0, dot); // trimming extension
-            printf("%d. [%s](source-code/%s)\n", ++serialNo, sFileName.c_str(), ent->d_name);
+            char buffer[512];
+	    sprintf(buffer, "[%s](source-code/%s)", sFileName.c_str(), ent->d_name);
+	    listItems.push_back(string(buffer));
         }
+	sort(listItems.begin(), listItems.end());
+	int serialNo = 0;
+	for(string const& item : listItems) {
+	    printf("%d. %s\n", ++serialNo, item.c_str());
+	}
         closedir (dir);
     } else {
         /* could not open directory */

readme-generator.cpp

@@ -7,6 +7,43 @@
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
+class BSTIterator {
+    stack<TreeNode*> nodeStack;
+    
+    void pushAllLefts(TreeNode* node) {
+        while(node) {
+            nodeStack.push(node);
+            node = node->left;
+        }
+    }
+public:
+    BSTIterator(TreeNode *root) {
+        pushAllLefts(root);
+    }
+
+    /** @return whether we have a next smallest number */
+    bool hasNext() {
+        return !nodeStack.empty();
+    }
+
+    /** @return the next smallest number */
+    int next() {
+        TreeNode* current = nodeStack.top();
+        nodeStack.pop();
+        pushAllLefts(current->right);
+        return current->val;
+    }
+};
+
+/**
+ * Your BSTIterator will be called like this:
+ * BSTIterator i = BSTIterator(root);
+ * while (i.hasNext()) cout << i.next();
+ */
+
+
+// more than O(h) extra space
+// O(n) space
 class BSTIterator {
     vector<int> nodes;
     vector<int>::iterator iter;
@@ -35,9 +72,3 @@ class BSTIterator {
         return (*iter++);
     }
 };
-
-/**
- * Your BSTIterator will be called like this:
- * BSTIterator i = BSTIterator(root);
- * while (i.hasNext()) cout << i.next();
- */

source-code/Binary_Search_Tree_Iterator.cpp

@@ -1,40 +1,68 @@
 class Solution {
 public:
-    bool hasCycle(int course, vector<vector<int> >& adj, vector<bool>& visited, vector<bool>& recursionStack) {
+    bool hasCycle(int course, vector<vector<int> >& adj, vector<bool>& visited) {
         visited[course] = true;
-        recursionStack[course] = true;
         for(int i = 0; i < (int)adj[course].size(); ++i) {
-            if(!visited[adj[course][i]]) {
-                if(hasCycle(adj[course][i], adj, visited, recursionStack)) {
+            if(visited[adj[course][i]]) {
+                return true;
+            }
+            if(hasCycle(adj[course][i], adj, visited)) {
+                return true;
+            }
+        }
+        visited[course] = false;
+        return false;
+    }
+    
+    enum Color {
+        WHITE, GREY, BLACK
+    };
+    
+    bool hasCycle2(int course, vector<vector<int>> const& adj, vector<int>& color) {
+        color[course] = GREY;
+        for(int i = 0; i < (int)adj[course].size(); ++i) {
+            int neigh = adj[course][i];
+            if(color[neigh] == GREY) {
+                return true;
+            }
+            if(color[neigh] == WHITE) {
+                if(hasCycle2(neigh, adj, color)) {
                     return true;
                 }
-            } else if(recursionStack[adj[course][i]]) {
-                return true;
             }
         }
-        recursionStack[course] = false;
+        color[course] = BLACK;
+        
         return false;
     }
+    
 
-    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
-       if(numCourses < 1) return true;
-       vector<vector<int> > adj;
-       adj.resize(numCourses);
-       int edges = prerequisites.size();
-       for(int i = 0; i < edges; ++i) {
-           int u = prerequisites[i][0];
-           int v = prerequisites[i][1];
+    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
+        if(numCourses < 1) return true;
+        vector<vector<int> > adj;
+        adj.resize(numCourses);
+        int edges = prerequisites.size();
+        for(int i = 0; i < edges; ++i) {
+           int u = prerequisites[i].first;
+           int v = prerequisites[i].second;
            adj[u].push_back(v);
-       }
-       vector<bool> visited(numCourses, false);
-       vector<bool> recursionStack(numCourses, false);
-       
-       for(int course = 0; course < numCourses; ++course) {
-           if(!visited[course]) {
-               if(hasCycle(course, adj, visited, recursionStack))
+        }
+        vector<bool> visited(numCourses, false);
+        vector<int> color(numCourses, WHITE);
+        /*
+        for(int course = 0; course < numCourses; ++course) {
+            if(!visited[course]) {
+                if(hasCycle(course, adj, visited))
+                    return false;
+            }
+        }
+        */
+        for(int course = 0; course < numCourses; ++course) {
+            if(color[course] == WHITE) {
+                if(hasCycle2(course, adj, color))
                     return false;
-           }
-       }
-       return true;
+            }
+        }
+        return true;
     }
 };

source-code/Course_Schedule.cpp

@@ -14,11 +14,19 @@ class Solution {
 };
 
 // iterative
-string convertToTitle(int n) {
-    string ans;
-    while (n-- != 0) {
-        ans = char(int('A') + n % 26) + ans;
-        n /= 26;
+class Solution {
+public:
+    string convertToTitle(int n) {
+        string ans = "";
+        while(n) {
+            if(n % 26 == 0) {
+                ans = 'Z' + ans;
+                n--;
+            } else {
+                ans = char('A' + (n % 26) - 1) + ans;
+            }
+            n /= 26;
+        }
+        return ans;
     }
-    return ans;
-}
+};

source-code/Excel_Sheet_Column_Title.cpp

@@ -0,0 +1,23 @@
+class Solution {
+    void killProcess(int kill, unordered_map<int, vector<int>>& adj, vector<int>& processes) {
+        for(auto pidIter = adj[kill].begin(); pidIter != adj[kill].end(); ++pidIter) {
+            killProcess(*pidIter, adj, processes);
+        }
+        processes.push_back(kill);
+    }
+    
+public:
+    vector<int> killProcess(vector<int>& pid, vector<int>& ppid, int kill) {
+        unordered_map<int, vector<int>> adj;
+        for(int i = 0; i < pid.size(); i++) {
+            if(adj.find(ppid[i]) == adj.end()) {
+                adj[ppid[i]] = vector<int>();
+            }
+            adj[ppid[i]].push_back(pid[i]);
+        }
+        vector<int> processes;
+        killProcess(kill, adj, processes);
+        
+        return processes;
+    }
+};

source-code/Kill_Process.cpp

@@ -1,15 +1,38 @@
+// two pointers O(n)
 class Solution {
+public:
+    int minSubArrayLen(int target, vector<int>& nums) {
+        int minLen = INT_MAX;
+        int n = nums.size();
+        if(n == 0) return 0;
+        int i = 0, k = 0, sum = 0;
+        while(i < n) {
+            sum += nums[i++];
+            while(sum >= target) {
+                minLen = min(minLen, i - k);
+                sum -= nums[k++];
+            }
+        }
+        return minLen == INT_MAX ? 0 : minLen;
+    }
+};
+
+// O(nlogn)
+class Solution {
+    // find the right-most occurance of value X such that X <= target
     int upperBound(vector<int> const& nums, int right, int target) {
         int left = 0;
-        while(left < right) {
+        int indx = -1;
+        while(left <= right) {
             int mid = left + (right - left) / 2;
             if(nums[mid] > target) {
-                right = mid;
+                right = mid - 1;
             } else if(nums[mid] <= target) {
+                indx = mid;
                 left = mid + 1;
             }
         }
-        return left;
+        return indx;
     }
 public:
     int minSubArrayLen(int target, vector<int>& nums) {
@@ -20,8 +43,8 @@ class Solution {
         for(int i = 0; i < n; ++i) {
             sum[i] = (i > 0 ? sum[i - 1] : 0) + nums[i];
             if(sum[i] >= target) {
-                int upper_bound = upperBound(sum, i, sum[i] - target);
-                minLen = min(minLen, i - upper_bound + 1);
+                int upper_bound = upperBound(sum, i - 1, sum[i] - target);
+                minLen = min(minLen, i - upper_bound);
             }
         }
         return (minLen != INT_MAX ? minLen : 0);

source-code/Minimum_Size_Subarray_Sum.cpp

@@ -34,17 +34,15 @@ class Solution {
         if(!head and !head->next) {
             return head;
         }
-        ListNode* prev = head;
-        ListNode* curr = head->next;
-        ListNode* tail = head;
-        while(curr) {
-            ListNode* nxt = curr->next;
-            curr->next = head;
-            head = curr;
-            curr= nxt;
-        }
-        tail->next = NULL;
-        
+        ListNode* curr = head;
+        ListNode* prev = nullptr;
+         while(curr) {
+             ListNode* nxt = curr->next;
+             curr->next = prev;
+             prev = curr;
+             head = curr;
+             curr = nxt;
+         }
         return head;
     }
 
@@ -67,9 +65,7 @@ class Solution {
                 fast = fast->next;
             } 
         }
-        ListNode* middleNode = NULL;
         if(length & 1) {
-            middleNode = slow;
             slow = slow->next;
         }
         ListNode* secondHalf = reverseList(slow);

source-code/Palindrome_Linked_List.cpp

@@ -9,17 +9,17 @@ class Solution {
      * @return    The number of characters read
      */
     int read(char *buf, int n) {
-        int cnt = 0;
+        int idx = 0;
         char* buf4 = new char[4];
-        while(cnt < n) {
+        while(idx < n) {
             int len = read4(buf4);
-            for(int i = 0; i < min(len, n - cnt); ++i) {
-                buf[cnt++] = buf4[i];
+            for(int i = 0, m = min(len, n - idx); i < m; ++i) {
+                buf[idx++] = buf4[i];
             }
             if(len < 4) {
                 break;
             }
         }
-        return cnt;
+        return idx;
     }
-};
+};