add top k word and sparse matrix mul

x007dwd · x007dwd · commit 8dfc37f95424 · 2017-06-11T09:45:51.000+08:00
diff --git a/.gitignore b/.gitignore
@@ -1,6 +1,8 @@
 *.kdev4*
 # Byte-compiled / optimized / DLL files
+*/.idea/*
 .idea/*
+*/cmake-build-debug/*
 __pycache__/
 *.py[cod]
 *$py.class
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
@@ -6,3 +6,5 @@ add_executable(String src/String.cpp)
 add_executable(BinTree src/BinTree.cpp)
 add_executable(LinkList src/LinkList.cpp)
 add_executable(sort src/sort.cpp)
+add_executable(sparse_matrix src/sparse_matrix_mul.cpp)
+add_executable(top_k src/top_k_words.cpp)
diff --git a/cpp/ReadeMe.md b/cpp/ReadeMe.md
@@ -0,0 +1,14 @@
+## top k words
+Hashing is used in this solution. The words are readed from a file and the hash table is constructed at same time. The complexity of this part is O(M), where M is words' quantity. The complexity of sort part to find the top-k is O(nlog(k)). The total is (M+nlog(k)).
+
+## sparse matrix multiplication
+The multiplication of two n×n matrices is one of the most basic algebraic problems and considerable effort was devoted to obtaining efficient algorithms for the task. The naive matrix multiplication algorithm performs O(n^3) operations. Strassen was the first to show that the naive algorithm is not optimal, giving an O(n^2.81) algorithm for the problem. Many improvements then followed. The currently fastest matrix multiplication algorithm, with a complexity of O(n^2.38 ), was obtained by Coppersmith and Winograd.
+
+Considering that there are 5% elements are nonzero, so the algorithmic complexity of sparse matrix multiplication is O(max(m,n,k) + 0.05 * max(m*n,n*k) ).
+
+After reading the question, it is obvious the data in matrix is float point, so I use float as the data precision, it is easy to change the data precision to double type.
+
+
+the running times of the two schemes (my code and the traditional one) when m = n = k = 1000 for the same generated matrices A and B is
+traditional matrix multiplication scheme use time 5.476 s
+sparse matrix multiplication scheme use time      1.701 s
diff --git a/cpp/data/example.txt b/cpp/data/example.txt
@@ -0,0 +1,5 @@
+Welcome to the world of Geeks..,,,,,,,,,,,,, . . . . . . 
+This portal has been created to provide well written well thought and well explained
+solutions for selected questions If you like Geeks for Geeks and would like to contribute
+here is your chance You can write article and mail your article to contribute at
+geeksforgeeks org See your article appearing on the Geeks for Geeks main page and helpthousands of other Geeks
diff --git a/cpp/data/example_2.txt b/cpp/data/example_2.txt
@@ -0,0 +1,2 @@
+Welcome to the world of Geeks 
+
diff --git a/cpp/src/String.cpp b/cpp/src/String.cpp
@@ -3,149 +3,155 @@
 #include <limits.h>
 #include <stack>
 #include <string>
+#include <vector>
+
+using namespace std;
 
 class StringSolution {
 public:
-
-  bool isValid(std::string const &s) {
-    std::stack<char> st;
-    for (auto c : s) {
-      if (c == '[' || c == '(' || c == '{') {
-        st.push(c);
-      }
-      if (c == ']' || c == ')' || c == '}') {
-        if (st.empty()) {
-          return false;
+    bool isValid(std::string const &s) {
+        std::stack<char> st;
+        for (auto c : s) {
+            if (c == '[' || c == '(' || c == '{') {
+                st.push(c);
+            }
+            if (c == ']' || c == ')' || c == '}') {
+                if (st.empty()) {
+                    return false;
+                }
+                char tmp = st.top();
+                if ((tmp == '[' && c == ']') || (tmp == '(' && c == ')') ||
+                    (tmp == '{' && c == '}')) {
+                    st.pop();
+                } else {
+                    return false;
+                }
+            }
         }
-        char tmp = st.top();
-        if ((tmp == '[' && c == ']') || (tmp == '(' && c == ')') ||
-            (tmp == '{' && c == '}')) {
-          st.pop();
-        } else {
-          return false;
+        if (!st.empty()) {
+            return false;
         }
-      }
-    }
-    if (!st.empty()) {
-      return false;
+        return true;
     }
-    return true;
-  }
-  std::string addBinary(std::string a, std::string b) {
-    std::string result;
-    int carry = 0;
-    reverse(a.begin(), a.end());
-    reverse(b.begin(), b.end());
-    unsigned int alen = a.size();
-    unsigned int blen = b.size();
-    std::string short_str = b;
-    std::string long_str = a;
-    if (alen < blen) {
-      short_str = a;
-      long_str = b;
-    }
-    for (size_t i = 0; i < short_str.size(); i++) {
-      unsigned int acc, val;
 
-      acc = short_str[i] + long_str[i] - 2 * '0' + carry;
-      carry = acc / 2;
-      val = acc % 2;
-      result.insert(result.begin(), val + '0');
-    }
-    size_t idx = short_str.size();
-    while (idx < long_str.size()) {
-      unsigned int acc, val;
-      acc = long_str[idx] - '0' + carry;
-      carry = acc / 2;
-      val = acc % 2;
-      idx++;
-      result.insert(result.begin(), val + '0');
-    }
-    if (carry) {
-      result.insert(result.begin(), '1');
-    }
-    return result;
-  }
-  int myAtoi(const std::string &str) {
-    auto start = str.begin();
-    int result = 0;
-    int sign = 1;
-    while (*start == ' ' && start != str.end()) {
-      start++;
+    std::string addBinary(std::string a, std::string b) {
+        std::string result;
+        int carry = 0;
+        reverse(a.begin(), a.end());
+        reverse(b.begin(), b.end());
+        unsigned int alen = a.size();
+        unsigned int blen = b.size();
+        std::string short_str = b;
+        std::string long_str = a;
+        if (alen < blen) {
+            short_str = a;
+            long_str = b;
+        }
+        for (size_t i = 0; i < short_str.size(); i++) {
+            unsigned int acc, val;
+
+            acc = short_str[i] + long_str[i] - 2 * '0' + carry;
+            carry = acc / 2;
+            val = acc % 2;
+            result.insert(result.begin(), val + '0');
+        }
+        size_t idx = short_str.size();
+        while (idx < long_str.size()) {
+            unsigned int acc, val;
+            acc = long_str[idx] - '0' + carry;
+            carry = acc / 2;
+            val = acc % 2;
+            idx++;
+            result.insert(result.begin(), val + '0');
+        }
+        if (carry) {
+            result.insert(result.begin(), '1');
+        }
+        return result;
     }
-    if (*start == '+') {
-      sign = 1;
-      start++;
-    } else if (*start == '-') {
-      sign = -1;
-      start++;
+
+    int myAtoi(const std::string &str) {
+        auto start = str.begin();
+        int result = 0;
+        int sign = 1;
+        while (*start == ' ' && start != str.end()) {
+            start++;
+        }
+        if (*start == '+') {
+            sign = 1;
+            start++;
+        } else if (*start == '-') {
+            sign = -1;
+            start++;
+        }
+        while (start != str.end()) {
+            if (*start > '9' || *start < '0') {
+                break;
+            }
+            if (result > INT_MAX / 10 ||
+                (result == INT_MAX && (*start - '0') > INT_MAX % 10)) {
+                return (sign == -1) ? INT_MIN : INT_MAX;
+            }
+            result *= 10;
+            result += *start - '0';
+            start++;
+        }
+        return result * sign;
     }
-    while (start != str.end()) {
-      if (*start > '9' || *start < '0') {
-        break;
-      }
-      if (result > INT_MAX / 10 ||
-          (result == INT_MAX && (*start - '0') > INT_MAX % 10)) {
-        return (sign == -1) ? INT_MIN : INT_MAX;
-      }
-      result *= 10;
-      result += *start - '0';
-      start++;
+
+    bool isPalindrome(std::string s) {
+        transform(s.begin(), s.end(), s.begin(), ::tolower);
+        auto left = s.begin(), right = prev(s.end());
+        while (left < right) {
+            if (!::isalnum(*left))
+                left++;
+            else if (!::isalnum(*right))
+                right--;
+            else if (*left != *right)
+                return false;
+            else {
+                left++;
+                right--;
+            }
+        }
+        return true;
     }
-    return result * sign;
-  }
-  bool isPalindrome(std::string s) {
-    transform(s.begin(), s.end(), s.begin(), ::tolower);
-    auto left = s.begin(), right = prev(s.end());
-    while (left < right) {
-      if (!::isalnum(*left))
-        left++;
-      else if (!::isalnum(*right))
-        right--;
-      else if (*left != *right)
-        return false;
-      else {
-        left++;
-        right--;
-      }
+
+    bool isMatch(const std::string &s, const std::string &p) {
+        return isMatch(s.c_str(), p.c_str());
     }
-    return true;
-  }
-  bool isMatch(const std::string &s, const std::string &p) {
-    return isMatch(s.c_str(), p.c_str());
-  }
 
 private:
-  bool isMatch(const char *s, const char *p) {
-    if (*p == '\0')
-      return *s == '\0';
-    // next char is not '*', then must match current character
-    if (*(p + 1) != '*') {
-      if (*p == *s || (*p == '.' && *s != '\0'))
-        return isMatch(s + 1, p + 1);
-      else
-        return false;
-    } else { // next char is '*'
-      while (*p == *s || (*p == '.' && *s != '\0')) {
-        if (isMatch(s, p + 2))
-          return true;
-        s++;
-      }
-      return isMatch(s, p + 2);
+    bool isMatch(const char *s, const char *p) {
+        if (*p == '\0')
+            return *s == '\0';
+        // next char is not '*', then must match current character
+        if (*(p + 1) != '*') {
+            if (*p == *s || (*p == '.' && *s != '\0'))
+                return isMatch(s + 1, p + 1);
+            else
+                return false;
+        } else { // next char is '*'
+            while (*p == *s || (*p == '.' && *s != '\0')) {
+                if (isMatch(s, p + 2))
+                    return true;
+                s++;
+            }
+            return isMatch(s, p + 2);
+        }
     }
-  }
 };
 
 int main(int argc, char const *argv[]) {
-  StringSolution sol;
-  std::string s = "AASS,DD.****SSAA";
-  std::string p = "ac*a";
-  std::cout << sol.isMatch(s, p) << std::endl;
-  std::cout << "is Palindrome" << std::endl;
-  std::cout << sol.isPalindrome(".,") << std::endl;
-  std::cout << "atoi\t" << sol.myAtoi("125") << std::endl;
-  std::cout << " add Binary\t" << sol.addBinary("1010", "1011") << std::endl;
-  printf("const std::string &)))");
-  std::cout << "is valid closure " << sol.isValid("[(11111]") << '\n';
-  return 0;
+    StringSolution sol;
+    std::string s = "AASS,DD.****SSAA";
+    std::string p = "ac*a";
+    std::cout << sol.isMatch(s, p) << std::endl;
+    std::cout << "is Palindrome" << std::endl;
+    std::cout << sol.isPalindrome(".,") << std::endl;
+    std::cout << "atoi\t" << sol.myAtoi("125") << std::endl;
+    std::cout << " add Binary\t" << sol.addBinary("1010", "1011") << std::endl;
+    printf("const std::string &)))");
+    std::cout << "is valid closure " << sol.isValid("[(11111]") << '\n';
+    return 0;
 }
diff --git a/cpp/src/sparse_matrix_mul.cpp b/cpp/src/sparse_matrix_mul.cpp
diff --git a/cpp/src/top_k_words.cpp b/cpp/src/top_k_words.cpp
