Game Theory, Number theory, String algorithms added

Author: kaidul-EB

.DS_Store

@@ -0,0 +1,32 @@
+/*
+General case for any k
+f(n, k) = ((f(n - 1, k) + k - 1) mod n) + 1, f(1, k) = 1 (when n = 1...8)
+*/
+int josephus(int n, int k) {
+    if(n == 1) return 0;
+    return (josephus(n - 1, k) + k) % n;
+}
+ 
+/*
+When k = 2
+Proof: wikipedia
+2 * (n - 2^floor(log2n)) + 1
+*/
+int josephusfor2(int n) {
+    return 2 * (n - pow(2, floor(log((double) n) / log(2.0)))) + 1;
+}
+ 
+/*
+ another proof for k = 2
+ source: wikipedia
+ n = 1b1b2b3b4...bm (bit representaion), ans = b1b2b3b4...bm1 (shifting leftmost bit into rightmost)
+*/
+int josephusfor2_bit(int n) {
+    n <<= 1;
+    n |= 1;
+    int bit = floor((double)log(n) / log(2.0));
+    int var = (1 << bit);
+    --var;
+    n &= var;
+    return n;
+}

Josephus_Recurrence.cpp

@@ -0,0 +1,22 @@
+int powerUtil(int base, int exp, int mod) {
+    if(exp == 0) return 1;
+    int ret = powerUtil(base, exp / 2, mod) % mod;
+    ret = 1LL * ret * ret % mod;
+    if(exp & 1) {
+        ret = 1LL * ret * base % mod;
+    }
+    return ret;
+}
+
+double power(int base, int exp, int mod = 1000000007) {
+    if(exp < 0) {
+        if(base == 0) return DBL_MAX; // undefined
+        return 1 / (double) powerUtil(base, -exp, mod); // return type will be double/long double then
+    }
+    return powerUtil(base, exp, mod);
+}
+
+// Modular mutiplicative inverse
+int modInv(int base, int mod = 1000000007) {
+    return powerUtil(base, mod - 2, mod);
+}

Power.cpp

@@ -1,19 +1,88 @@
-## Classical Data Structures and Algorithms
+## Data Structures and Algorithms for Online Programming Contest
+
+### Data Structure
++ [Union Find(Disjoint Set)](union_find.cpp)
+
+### Dynamic Programming
 
 ### String Algorithm
++ [Knuth-Morris-Pratt’s Algorithm](knuth.cpp)
++ [Rabin Karp Pattern Searching](rabin_karp.cpp)
++ [Z Algorithm](z.cpp)
 + [Finite Automata Pattern Searching](Finite_Automata_Pattern_Searching.cpp)
++ [Trie (Prefix/Radix Tree)](Trie.cpp)
++ [Longest Common Subsequence](lcs.cpp)
++ [Edit Distance](edit_distance.cpp)
++ [Longest Palindromic Subsequence](lps.cpp)
++ [Suffix Array](suffix_lcp.cpp)
++ [Longest Common Prefix](suffix_lcp.cpp)
 + [Minimum Expression](Minimum_expression.cpp)
++ [Suffix Automata](suffix_automata.cpp)
+
+### Graph Theory
++ [Lowest Common Ancestor(sparse table)](lca.cpp)
+
 
 ### Dynamic Programming
 + [Digit Dp I](Digit_DP_I.cpp)
 
+### Mathematics
++ [Power Function(Big mod)](Power.cpp)
++ [Modular Mutiplicative Inverse(using Big mod)](Power.cpp)
++ [Prime(Sieve of Erathonesis)](prime.cpp)
++ [Segmented Sieve of Erathonesis](prime.cpp)
++ [Prime factorization(using Sieve)](prime.cpp)
++ [Prime factorization](prime.cpp)
++ [Primality Test(School method)](primality_test.cpp)
++ [Miller–Rabin Primality Test](primality_test.cpp)
++ [Extended Euclid](extended_euclid.cpp)
++ [Linear Diophatine Equation](extended_euclid.cpp)
++ [Modular Mutiplicative Inverse(using Extended Euclid)](extended_euclid.cpp)
++ [Matrix Exponenciation](matrix_exp.xpp)
++ [Floyd Cycle Finding Algorithm](floyd_cycle_finding.cpp)
++ [Big Integer](big_integer.cpp)
++ [Josephus Recurrence](Josephus_Recurrence.cpp)
+
+### Combinotorics
++ [Factorial](factorial.cpp)
++ [nCr](ncr.cpp)
++ [De-arrangement](dearrangement.cpp)
+
+### Game Theory
++ [Game Tree(Memorization)](game_tree.cpp)
++ [Nim](nim.cpp)
++ [Misère Nim](nim.cpp)
++ [Nimble Nim](nim.cpp)
++ [Poker Nim](nim.cpp)
++ [Prime Power Nim](nim.cpp)
++ [Spagrue Grundy Problem](grundy.cpp)
++ [Grundy Variant: Zero Nim Game](grundy.cpp)
++ [Grundy Variant: Coins on Chessboard](grundy.cpp)
++ [Green HackenBush(Colon Principle)](hackenbush.cpp)
+
+### Binary Search
+
++ [Binary Search](binary_search.cpp)
++ [Lower Bound](binary_search.cpp)
++ [Upper Bound](binary_search.cpp)
++ [Equal Range](binary_search.cpp)
+
+### Hashing
++ [Double Hashing](double_hashing.cpp)
++ [String Hashing by Map](map_hashing.cpp)
++ [Berenstain String Hashing](berenstain_hashing.cpp)
++ [Rolling Hash](rabin_karp.cpp)
+
 ### Sorting
 + [Merge Sort](Merge_Sort.cpp)
 + [Quick Sort](Quick_Sort.cpp)
++ [Heap Sort](heap_sort.cpp)
 + [Bubble Sort](Bubble_Sort.cpp)
 + [Insertion Sort](Insertion_Sort.cpp)
 + [Selection Sort](Selection_Sort.cpp)
 + [Bucket Sort](Bucket_Sort.cpp)
 + [Count Sort](Count_Sort.cpp)
 + [Radix Sort](Radix_Sort.cpp)
 + [Pancake Sort](Pancake_Sort.cpp)
+
++ [Template](template.cpp)

README.md

@@ -0,0 +1,52 @@
+const static int SIZE = 30;
+const static int NOT_FOUND = -1;
+class trie {
+private:
+    struct trieNode {
+        int mark;
+        trieNode* children[SIZE];
+        trieNode(): mark(NOT_FOUND) {
+            for(int i = 0; i < SIZE; ++i) {
+                children[i] = nullptr;
+            }
+        }
+        ~trieNode() {
+            for(int i = 0; i < MAX; ++i) {
+                delete children[i];
+                children[i] = nullptr;
+            }
+        }
+    };
+    trieNode* root;
+public:
+    trie(): root(new trieNode()) {
+    }
+    ~trie() {
+        delete root;
+        root = nullptr;
+    }
+    
+    void insert(string const& key, int id) {
+        trieNode* pCrawl = root;
+        for(int i = 0; i < key.length(); ++i) {
+            int indx = key[i] - 'a';
+            if(!pCrawl->children[indx]) {
+                pCrawl->children[indx] = new trieNode();
+            }
+            pCrawl = pCrawl->children[indx];
+        }
+        pCrawl->mark = id;
+    }
+    
+    int search(string const& key) {
+        trieNode *pCrawl = root;
+        for(int i = 0; i < key.length(); ++i) {
+            int indx = key[i] - 'a';
+            if(!pCrawl->children[indx]) {
+                return NOT_FOUND;
+            }
+            pCrawl = pCrawl->children[indx];
+        }
+        return pCrawl->mark;
+    }
+};    

Trie.cpp

@@ -0,0 +1,16 @@
+/*
+Source: Zobayer Blog
+Must use unsigned type.
+hash = hash * 33 ^ c, reliable hash
+*/
+ 
+#define u64 unsigned long long
+ 
+u64 hash(string const& s) {
+    u64 hash = 0;
+    for(int i = 0; i < (int)s.length(); i++) {
+    	int c = s[i];
+    	hash = ((hash << 5) + hash) ^ c;
+    }
+    return hash;
+}

berenstain_hashing.cpp

@@ -0,0 +1,117 @@
+struct BigInt {
+    // representations and structures
+    string a; // to store the digits
+    int sign; // sign = -1 for negative numbers, sign = 1 otherwise
+    
+    // constructors
+    BigInt() {} // default constructor
+    BigInt( string b ) {
+        (*this) = b;    // constructor for string
+    }
+    
+    // some helpful methods
+    int size() { // returns number of digits
+        return a.size();
+    }
+    BigInt inverseSign() { // changes the sign
+        sign *= -1;
+        return (*this);
+    }
+    BigInt normalize( int newSign ) { // removes leading 0, fixes sign
+        for( int i = a.size() - 1; i > 0 && a[i] == '0'; i-- )
+            a.erase(a.begin() + i);
+        sign = ( a.size() == 1 && a[0] == '0' ) ? 1 : newSign;
+        return (*this);
+    }
+    
+    // assignment operator
+    void operator = ( string b ) { // assigns a string to BigInt
+        a = b[0] == '-' ? b.substr(1) : b;
+        reverse( a.begin(), a.end() );
+        this->normalize( b[0] == '-' ? -1 : 1 );
+    }
+    
+    // conditional operators
+    bool operator < ( const BigInt &b ) const { // less than operator
+        if( sign != b.sign ) return sign < b.sign;
+        if( a.size() != b.a.size() )
+            return sign == 1 ? a.size() < b.a.size() : a.size() > b.a.size();
+        for( int i = a.size() - 1; i >= 0; i-- ) if( a[i] != b.a[i] )
+            return sign == 1 ? a[i] < b.a[i] : a[i] > b.a[i];
+        return false;
+    }
+    bool operator == ( const BigInt &b ) const { // operator for equality
+        return a == b.a && sign == b.sign;
+    }
+    
+    
+    
+    // mathematical operators
+    BigInt operator + ( BigInt b ) { // addition operator overloading
+        if( sign != b.sign ) return (*this) - b.inverseSign();
+        BigInt c;
+        for(int i = 0, carry = 0; i<a.size() || i<b.size() || carry; i++ ) {
+            carry+=(i<a.size() ? a[i]-48 : 0)+(i<b.a.size() ? b.a[i]-48 : 0);
+            c.a += (carry % 10 + 48);
+            carry /= 10;
+        }
+        return c.normalize(sign);
+    }
+    BigInt operator - ( BigInt b ) { // subtraction operator overloading
+        if( sign != b.sign ) return (*this) + b.inverseSign();
+        int s = sign;
+        sign = b.sign = 1;
+        if( (*this) < b ) return ((b - (*this)).inverseSign()).normalize(-s);
+        BigInt c;
+        for( int i = 0, borrow = 0; i < a.size(); i++ ) {
+            borrow = a[i] - borrow - (i < b.size() ? b.a[i] : 48);
+            c.a += borrow >= 0 ? borrow + 48 : borrow + 58;
+            borrow = borrow >= 0 ? 0 : 1;
+        }
+        return c.normalize(s);
+    }
+    BigInt operator * ( BigInt b ) { // multiplication operator overloading
+        BigInt c("0");
+        for( int i = 0, k = a[i] - 48; i < a.size(); i++, k = a[i] - 48 ) {
+            while(k--) c = c + b; // ith digit is k, so, we add k times
+            b.a.insert(b.a.begin(), '0'); // multiplied by 10
+        }
+        return c.normalize(sign * b.sign);
+    }
+    BigInt operator / ( BigInt b ) { // division operator overloading
+        if( b.size() == 1 && b.a[0] == '0' ) b.a[0] /= ( b.a[0] - 48 );
+        BigInt c("0"), d;
+        for( int j = 0; j < a.size(); j++ ) d.a += "0";
+        int dSign = sign * b.sign;
+        b.sign = 1;
+        for( int i = a.size() - 1; i >= 0; i-- ) {
+            c.a.insert( c.a.begin(), '0');
+            c = c + a.substr( i, 1 );
+            while( !( c < b ) ) c = c - b, d.a[i]++;
+        }
+        return d.normalize(dSign);
+    }
+    BigInt operator % ( BigInt b ) { // modulo operator overloading
+        if( b.size() == 1 && b.a[0] == '0' ) b.a[0] /= ( b.a[0] - 48 );
+        BigInt c("0");
+        b.sign = 1;
+        for( int i = a.size() - 1; i >= 0; i-- ) {
+            c.a.insert( c.a.begin(), '0');
+            c = c + a.substr( i, 1 );
+            while( !( c < b ) ) c = c - b;
+        }
+        return c.normalize(sign);
+    }
+    
+    // faster output method
+    void _print() {
+        if( sign == -1 ) putchar('-');
+        for( int i = a.size() - 1; i >= 0; i-- ) putchar(a[i]);
+    }
+};
+
+ostream& operator << (ostream& os, const BigInt& obj) {
+    if( obj.sign == -1 ) os << "-";
+    for( int i = obj.a.size() - 1; i >= 0; i--) os << obj.a[i];
+    return os;
+}

big_integer.cpp

@@ -0,0 +1,47 @@
+int lowerBound(vector<int>& arr, int target) {
+    int n = (int)arr.size();
+    int left = 0, right = n - 1;
+    int indx = -1;
+    while(left <= right) {
+        int mid = left + (right - left) / 2;
+        if(arr[mid] == target) {
+            indx = mid;
+        }
+        if(arr[mid] < target) {
+            left = mid + 1;
+        } else { // arr[mid] >= target
+            right = mid - 1;
+        }
+    }
+    return indx;
+}
+
+// different from C++ upper_bound. return target's index inclusive
+int upperBound(vector<int>& arr, int target) {
+    int n = (int)arr.size();
+    int left = 0, right = n - 1;
+    int indx = -1;
+    while(left <= right) {
+        int mid = left + (right - left) / 2;
+        if(arr[mid] == target) {
+            indx = mid;
+        }
+        if(arr[mid] <= target) {
+            left = mid + 1;
+        } else { // arr[mid] > target
+            right = mid - 1;
+        }
+    }
+    return indx;
+}
+
+pair<int, int> equalRange(vector<int>& arr, int target) {
+    int lbound = lowerBound(arr, target);
+    int ubound = upperBound(arr, target);
+    return pair<int, int>{lbound, ubound};
+}
+
+int binarySearch(vector<int>& arr, int target) {
+    int lbound = lowerBound(arr, target);
+    return lbound;
+}

binary_search.cpp

@@ -0,0 +1,6 @@
+int d(int n) {
+    if(n == 2) return 1;
+    if(n == 1) return 0;
+    if(dp[n] != -1) return dp[n];
+    return dp[n] = (n - 1) * (d(n - 1) + d(n - 2));
+}