Added Some famous Algorithms

Author: darkcoderrises

Calc_nCr.cpp

@@ -0,0 +1,55 @@
+#include<iostream>
+#include<vector>
+
+using namespace std;
+
+const long long int MOD=1e9+7;
+long long int n,t,m,ans;
+
+long long in(long long int a)
+{
+        long long b=MOD-2;
+        long long x=1,y=a;
+        while(b > 0)
+        {
+            if(b%2 == 1)
+            {
+                x=(x*y);
+                if(x>MOD) x%=MOD;
+            }
+                y = (y*y);
+                if(y>MOD) y%=MOD;
+                b /= 2;
+        }
+                return x;
+}
+
+long long int C(int n, int r)
+{
+    vector<long long> f(n+1,1);
+    for(int i=2;i<n+1;i++)
+    {
+        f[i]=(f[i-1]*i)%MOD;
+    }
+    return((f[n]*((in(f[r])*in(f[n-r]))%MOD))%MOD);
+
+}
+
+int main()
+{
+    cin>>t;
+    for(int i=0;i<t;i++)
+    {
+        cin>>n;
+        ans=0;
+        int a=1;
+        for(int j=0;j<n;j++)
+        {
+            cin>>m;
+            cout<<C(n-1,j)<<endl;
+            ans=(ans+(a*C(n-1,j)*m)%MOD)%MOD;
+            a=a*-1;
+        }
+        cout<<ans<<endl;
+    }
+}

Sieve_of_Eratosthenes.cpp

@@ -0,0 +1,50 @@
+#include<iostream>
+#include<bitset>
+using namespace std;
+
+int primes[3000100]; //list of primes
+bitset <30000000> P; //instant prime check with boolean table
+
+void generate( int N ) //sieve
+{
+    P[2] = 1;
+    primes[0] = 2; //set 2 as prime
+    bool prime;
+    int ct = 1, i, j;
+    for ( i = 3; i <= N; i++ ) //range to sieve
+    {
+        prime = true;
+        for ( j = 0; primes[j]*primes[j] <= i; j++ ) //loop through previous primes until root of current number to check
+        {
+            if ( i % primes[j] == 0 )
+            {
+                prime = false; //not prime
+                break;
+            }
+        }
+        if ( prime )
+        {
+            primes[ct] = i; //add to list of primes
+            ct++;
+            P[i] = true; //add to boolean table
+        }
+    }
+}
+
+int main()
+{
+    int N;
+    cin>>N; //specify range
+    generate(N);
+
+    while ( 1 )
+    {
+        cout<<"Enter 0 to end loop or N to check if N is prime:\n";
+        cin>>N;
+        if ( !N ) break;
+        P[N] ? cout<<"Yes\n" : cout<<"No\n";
+    }
+
+    return 0;
+}
+

String Searching - KMP.cpp

@@ -0,0 +1,95 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cmath>
+#include<cstring>
+#include<stack>
+#include<queue>
+#include<deque>
+#include<vector>
+#include<map>
+#include<set>
+#include<bitset>
+#include<ctime>
+#include<limits>
+#include<iomanip>
+#include<cstdlib>
+#include<list>
+#include<functional>
+#include<numeric>
+#include<utility>
+#include<sstream>
+
+#define MAXIMUM ( 1 << 31 ) - 1
+#define MINIMUM ( 1 << 31 )
+#define pb push_back
+#define endl '\n'
+
+typedef long long ll;
+using namespace std;
+
+bool match[100005]; //All indices where pattern is present are 1
+string TEXT, PATTERN; //Text to search and pattern to search for
+int F[1000]; //Stores automaton states. Every index represents the largest partial match a prefix of that size has.
+
+void build() //builds automaton for the pattern
+{
+    int i, j;
+    F[0] = F[1] = 0; //always true
+    for ( i = 2; i <= PATTERN.length(); i++ )
+    //we go an extra step because the failure function is 1-indexed 
+    //PATTERN is still 0 indexed
+    //The 0 index in the array F represents an empty string. Every consequent element represents prefix of that length
+    {                                   
+        j = F[i - 1];
+        while ( true )
+        {
+            if ( PATTERN[j] == PATTERN[i-1] ) //If the char that extends partial match is same as last char of curr prefix
+            {
+                F[i] = j+1;
+                break;
+            }
+            else if ( j == 0 ) //The best match is an empty string
+            {
+                F[i] = 0;
+                break;
+            }
+            else j = F[j]; //Check for an even smaller partial match
+        }
+    }
+}
+
+int find()
+{
+    build();
+    int i = 0, j = 0, ct = 0; //i loops over TEXT, j over PATTERN. ct is counts of patterns.
+    while ( true )
+    {
+        if ( i == TEXT.length() ) break; //Full TEXT has been searched
+        if ( TEXT[i] == PATTERN[j] ) //The state of the automata can be extended to the next one
+        {
+            i++;
+            j++;
+            if ( j == PATTERN.length() ) //Match found
+            {
+                match[i - PATTERN.length()] = true; //Mark indice
+                ct++;
+                j = F[j]; //Since a full match has been found, we can start at this index of TEXT and assume that another
+                //smaller match has already been extended up till F[j]
+            }
+        }
+        else if ( j ) j = F[j]; //If you can't extend this match, see if you can extend a smaller match
+        else i++; //Can't extend shit on this TEXT index, try with the next one
+    }
+    return ct;
+}
+
+
+int main()
+{
+    int i, j, k;
+    cin>>TEXT>>PATTERN;
+    cout<<find()<<endl;
+
+    return 0;
+}

bfs.cpp

@@ -0,0 +1,35 @@
+/* Breadth First Search
+ * Number of Vertices: n
+ * Source: s
+ * Distance Array: dist[]
+ * Adjacency List: adj[][]
+ * Infinite Constant: inf
+ */
+
+void bfs()
+{
+    for(int i=0;i<n;++i)
+    {
+        dist[i] = inf;
+    }
+
+    queue<int> q;
+    q.push(s);
+    dist[s] = 0;
+
+    while(!q.empty())
+    {
+        int u = q.front();
+        q.pop();
+
+        for(int i=0;i<adj[u].size();++i)
+        {
+            int v = adj[u][i];
+            if(dist[v]==inf)
+            {
+                dist[v] = dist[u]+1;
+                q.push(v);
+            }
+        }
+    }
+}

dfs.cpp

@@ -0,0 +1,17 @@
+/* Depth First Search
+ * Adjacency List: adj[][]
+ * Visited Check: vis[]
+ */
+
+void dfs(int u)
+{
+    vis[u] = 1;
+    for(int i=0;i<adj[u].size();++i)
+    {
+        int v = adj[u][i];
+        if(!vis[v])
+        {
+            dfs(v);
+        }
+    }
+}

dijkstra.cpp

@@ -0,0 +1,40 @@
+/* Dijkstra's Single Source Shortest Path Algorithm
+ * Number of Vertices: n
+ * Source: s
+ * Distance Array: dist[]
+ * Adjacency List: adj[][] tuple(vertex, weight)
+ * Infinte Constant: inf
+ */
+
+void dijkstra()
+{
+    for(int i=0;i<n;++i) 
+    {
+        dist[i] = inf;
+    }
+
+    set< tuple<int,int> > q;
+    dist[s] = 0;
+    q.insert(make_tuple(0,s));
+
+    while(!q.empty())
+    {
+        int u = get<1>(*q.begin());
+
+        for(int i=0; i<adj[u].size(); ++i)
+        {
+            int v = get<0>(adj[u][i]);
+            int w = get<1>(adj[u][i]);
+            
+            if(dist[v] > dist[u]+w) 
+            {
+                if(dist[v] != inf)
+                {
+                    q.erase(q.find(make_tuple(dist[v],v)));
+                }
+                dist[v] = dist[u]+w;
+                q.insert(make_tuple(dist[v],v));
+            }
+        }
+    }
+}

kruskal.cpp

@@ -0,0 +1,53 @@
+/* Kruskal's Minimum Spanning Tree Algorithm
+ * Edge List: e tuple(weight,a,b)
+ * Number of Edges: m
+ * Number of Vertices: n
+ * Parent in DS: par[]
+ * Height in DS: rank[]
+ */
+
+int findPar(int v)
+{
+    if(par[v]==v)
+    {
+        return v;
+    }
+    par[v] = findPar(par[v]);
+}
+
+void merge(int a, int b)
+{
+    if(rank[a] < rank[b])
+    {
+        par[a] = b;
+    }
+    else
+    {
+        par[b] = a;
+        if(rank[a] == rank[b])
+        {
+            rank[a]++;
+        }
+    }
+}
+
+void kruskal()
+{
+    sort(e,e+m);
+    
+    for(int i=0;i<n;++i)
+    {
+        rank[i] = 1;
+        par[i] = i;
+    }
+
+    for(int i=0;i<m;++i)
+    {
+        int a = get<1>(e), b = get<2>(e);
+
+        if(findPar(a) != findPar(b)) 
+        {
+            merge(findPar(a),findPar(b));
+        }
+    }
+}