update

Author: anson627

ImplementStrStr/ImplementStrStr.cpp

@@ -6,6 +6,7 @@
 //
 // Complexity:
 // brute force, O(n*m) time, O(1) space
+// Rabin - Karp(RK), O(n + m) average and O(n*m) worst case time, O(1) space
 // Knuth-Morris-Pratt Algorithm (KMP), O(n+m) time, O(n) space
 //============================================================================
 
@@ -15,13 +16,15 @@
 
 using namespace std;
 
+#define B 31 // >= size of the alphabet 
+#define M 29989 // a large enough prime number
+
 class Solution {
 public:
     char * strStr(char * haystack, char * needle) {
-        return strStr3(haystack, needle);
+        return strStr2(haystack, needle);
     }
 
-
     char *strStr1(char *haystack, char *needle) {
         if (haystack == NULL || needle == NULL) return NULL;
         int n = strlen(haystack), m = strlen(needle);
@@ -33,7 +36,33 @@ class Solution {
         return NULL;
     }
 
+    int mod(int a, int b) {
+        return (a % b + b) % b;
+    }
+
     char *strStr2(char *haystack, char *needle) {
+        if (haystack == NULL || needle == NULL) return NULL;
+        int n = strlen(haystack), m = strlen(needle);
+        int hn = 0;
+        for (int i = 0; i < m; i++) hn = mod(hn*B + needle[i], M);
+        int hh = 0;
+        for (int i = 0; i < m; i++) hh = mod(hh*B + haystack[i], M);
+        if (hh == hn) return haystack;
+        int E = 1; // E = B^(m-1)
+        for (int i = 1; i < m; i++) E = mod(E*B, M);
+        for (int i = m; i < n; i++) {
+            hh = mod(hh - mod(haystack[i - m] * E, M), M);
+            hh = mod(hh*B + haystack[i], M);
+            if (hh == hn) {
+                int j = 0;
+                while (j < m && haystack[i + j] == needle[j]) j++;
+                return haystack + i - m + 1;
+            }
+        }
+        return NULL;
+    }
+
+    char *strStr3(char *haystack, char *needle) {
         if (haystack == NULL || needle == NULL) return NULL;
         int m = strlen(needle);
         if (m == 0) return haystack;

MedianofTwoSortedArrays/MedianofTwoSortedArrays.cpp

@@ -26,9 +26,9 @@ class Solution {
     }
 
     double findMedianSortedArrays(int A[], int m, int B[], int n) {
-        int total = m + n;
-        if (total % 2) return findKth(A, m, B, n, total / 2 + 1);
-        return (findKth(A, m, B, n, total / 2) + findKth(A, m, B, n, total / 2 + 1)) / 2.0;
+        int total = m + n, half = total / 2;
+        if (total % 2) return findKth(A, m, B, n, half + 1);
+        return (findKth(A, m, B, n, half) + findKth(A, m, B, n, half + 1)) / 2.0;
     }
 
     int findKth(int A[], int m, int B[], int n, int k) {

WordLadderII/WordLadderII.cpp

@@ -30,37 +30,43 @@ using namespace std;
 
 class Solution {
 public:
-    vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict) {
-        unordered_map<string, vector<string> > from;
+    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
         unordered_set<string> cq, nq, visit;
+        unordered_map<string, vector<string> > froms;
         cq.insert(start);
         while (!cq.empty() && !cq.count(end)) {
             for (auto & cur : cq) visit.insert(cur);
             for (auto & cur : cq) {
-                string next = cur;
+                auto next = cur;
                 for (int i = 0; i < next.size(); i++) {
                     char t = next[i];
                     for (char c = 'a'; c <= 'z'; c++) {
                         next[i] = c;
-                        if (next == end || (dict.count(next) && !visit.count(next))) from[next].push_back(cur), nq.insert(next);
+                        if (next == end || (dict.count(next) && !visit.count(next))) nq.insert(next), froms[next].push_back(cur);
                     }
                     next[i] = t;
                 }
             }
             swap(cq, nq);
             nq.clear();
         }
-        vector<vector<string> > res;
         vector<string> path;
-        getPath(end, start, from, path, res);
+        vector<vector<string> > res;
+        path.push_back(end);
+        go(end, start, froms, path, res);
         return res;
     }
 
-    void getPath(string & cur, string & start, unordered_map<string, vector<string> > & from, vector<string> & path, vector<vector<string> > & res) {
-        path.push_back(cur);
-        if (cur == start) res.push_back(vector<string>(path.rbegin(), path.rend()));
-        else for (auto next : from[cur]) getPath(next, start, from, path, res);
-        path.pop_back();
+    void go(string & cur, string & end, unordered_map<string, vector<string> > & froms, vector<string> & path, vector<vector<string> > & res) {
+        if (cur == end) {
+            res.push_back(vector<string>(path.rbegin(), path.rend()));
+            return;
+        }
+        for (auto & next : froms[cur]) {
+            path.push_back(next);
+            go(next, end, froms, path, res);
+            path.pop_back();
+        }
     }
 };