Add basic programming templates

Author: coderick14

.gitignore

@@ -0,0 +1 @@
+a.out

LCS.cpp

@@ -0,0 +1,45 @@
+//Longest Common Subsequence
+//Time complexity O(mn)
+//Space complexity O(mn)
+#include <bits/stdc++.h>
+using namespace std;
+
+void printLCS(char s1[], char s2[]) {
+    int i,j;
+    int m = strlen(s1);
+    int n = strlen(s2);
+    int LCS[m+1][n+1];
+    for(i=0; i<=m; i++) {
+        for(j=0; j<=n; j++) {
+            if(i==0 || j==0)
+                LCS[i][j] = 0;
+            else if(s1[i-1] == s2[j-1])
+                LCS[i][j] = 1 + LCS[i-1][j-1];
+            else
+                LCS[i][j] = max(LCS[i-1][j], LCS[i][j-1]);
+        }
+    }
+    int index = LCS[m][n];
+    char lcs[index+1];
+    lcs[index] = '\0';
+    i = m; j = n;
+    while(i > 0 && j > 0)   {
+        if(s1[i-1] == s2[j-1])  {
+            lcs[index-1] = s1[i-1];
+            i--; j--; index--;
+        }
+        else if(LCS[i-1][j] > LCS[i][j-1])
+            i--;
+        else
+            j--;
+    }
+    cout<<lcs<<endl;
+}
+
+int main()  {
+    char s1[30],s2[30];
+    cin>>s1;
+    cin>>s2;
+    printLCS(s1,s2);
+    return 0;
+}

LPS.cpp

@@ -0,0 +1,44 @@
+//Longest palindromic substring in O(n^2) time and O(1) space
+
+#include <iostream>
+#include <string.h>
+using namespace std;
+
+int longPalSubstr(char str[])   {
+    int n = strlen(str);
+    int i,low,high,len=1,start=0,maxlen=1;
+    for(i=1;i<n;i++)    {
+        //find even length substrings centred at i-1 and i
+        low=i-1; high=i;
+        while(low>=0 && high<n && str[low]==str[high])  {
+            len = high-low+1;
+            low--; high++;
+        }
+        if(len>maxlen)  {
+            maxlen = len;
+            start = i - len/2;
+        }
+
+        //find odd length substring centred at i
+        low=i-1; high=i+1;
+        while(low>=0 && high<n && str[low]==str[high])  {
+            len = high-low+1;
+            low--; high++;
+        }
+        if(len>maxlen)  {
+            maxlen = len;
+            start = i - len/2;
+        }
+    }
+    cout<<"Longest palindromic substring : ";
+    for(i=start;i<start+maxlen;i++)
+        cout<<str[i];
+    return maxlen;
+}
+
+int main()  {
+    char str[20];
+    cin>>str;
+    cout<<"\nLength : "<<longPalSubstr(str)<<"\n";
+    return 0;
+}

bfs.cpp

@@ -0,0 +1,43 @@
+#include <bits/stdc++.h>
+#define ll long long
+using namespace std;
+
+struct node {
+    bool visited;
+    ll dist;
+    vector<ll> adj;
+};
+
+int main() {
+    ll n,e,i,s,u,v,d;
+    cin>>n>>e;
+    vector<node> graph(n+1);
+    for(i=0;i<n;i++) {
+        graph[i].visited = false;
+        graph[i].dist = 0;
+    }
+    for(i=0;i<e;i++) {
+        cin>>u>>v;
+        graph[u].adj.push_back(v);
+        graph[v].adj.push_back(u);
+    }
+    cin>>s;
+    queue<ll> q;
+    q.push(s);
+    graph[s].dist = 0;
+    graph[s].visited = true;
+    while(!q.empty()) {
+        s = q.front();
+        q.pop();
+        cout<<s<<" "<<graph[s].dist<<endl;
+        for(i=0;i<graph[s].adj.size();i++) {
+            d = graph[s].adj[i];
+            if(!graph[d].visited) {
+                graph[d].visited = true;
+                graph[d].dist = graph[s].dist + 1;
+                q.push(d);
+            }
+        }
+    }
+    return 0;
+}

disjointsets.cpp

@@ -0,0 +1,57 @@
+#include <iostream>
+#include <vector>
+#define ll long long
+using namespace std;
+
+void make_set(vector<ll> &id, vector<ll> &rank, ll n) {
+    for(ll i=1; i<=n; i++) {
+        id[i] = i;
+        rank[i] = 1;
+    }
+}
+
+ll find_set(vector<ll> &id, ll p) {
+    ll root = p;
+    //find the root
+    while(root != id[root]) {
+        root = id[root];
+    }
+    //perform path compression
+    while(p != root) {
+        ll newp = id[p];
+        id[p] = root;
+        p = newp;
+    }
+    return root;
+}
+
+void merge_set(vector<ll> &id, vector<ll> &rank, ll x, ll y) {
+    x = find_set(id, x);
+    y = find_set(id, y);
+    if(rank[x] > rank[y])
+        id[y] = x;
+    else
+        id[x] = y;
+    if(rank[x] == rank[y])
+        rank[y] += 1;
+}
+
+int main() {
+	ll i,n,res = 0;
+	cin>>n;
+	vector<ll> forest(n+1), rank(n+1), id(n+1);
+	for(i=1;i<=n;i++) {
+	    cin>>forest[i];
+	}
+	make_set(id, rank, n);
+	for(i=1;i<=n;i++) {
+	    merge_set(id, rank, i, forest[i]);
+	}
+	for(i=1;i<=n;i++) {
+	    if(id[i] == i)
+	        res++;
+	}
+	cout<<res;
+	return 0;
+}
+

editDistance.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+#include <algorithm>
+#include <string.h>
+using namespace std;
+
+int editDistance(char s1[],char s2[])  {
+    int m=strlen(s1);
+    int n=strlen(s2);
+    int dp[m+1][n+1];
+    for(int i=0;i<=m;i++)   {
+        for(int j=0;j<=n;j++)   {
+            if(i==0)
+                dp[i][j]=j;
+            else if(j==0)
+                dp[i][j]=i;
+            else if(s1[i-1]==s2[j-1])
+                dp[i][j]=dp[i-1][j-1];
+            else
+                dp[i][j]=1+min(dp[i][j-1],min(dp[i-1][j],dp[i-1][j-1]));
+        }
+    }
+    return dp[m][n];
+}
+
+int main()  {
+    char s1[30],s2[30];
+    cout<<"Hi";
+    cin>>s1;
+    cin>>s2;
+    cout<<"\nEdit distance : "<<editDistance(s1,s2)<<"\n";
+    return 0;
+}

extendedEuclid.cpp

@@ -0,0 +1,30 @@
+#include <bits/stdc++.h>
+#define ll long long
+using namespace std;
+
+ll xGCD(ll a, ll b, ll &x, ll &y) {
+    if(b == 0) {
+        x = 1;
+        y = 0;
+        return a;
+    }
+
+    ll x1, y1, gcd = xGCD(b, a % b, x1, y1);
+    x = y1;
+    y = x1 - (a / b) * y1;
+    return gcd;
+}
+
+int main() {
+    ll a,b,c,x,y;
+    cin>>a>>b>>c;
+    ll gcd = xGCD(a,b,x,y);
+    if(c%gcd == 0) {
+        ll factor = c/gcd;
+        cout<<"x = "<<x*factor<<"\ny = "<<y*factor<<endl;
+    }
+    else {
+        cout<<"Solution does not exist\n";
+    }
+    return 0;
+}

segmentedSieve.cpp

@@ -0,0 +1,20 @@
+//Program to generate all primes in the range[m,n]
+//seg_sieve[i] indicates whether i+m is prime or not
+#include <bits/stdc++.h>
+#define ll long long
+using namespace std;
+
+int main() {
+    ll m,n;
+    cin>>m>>n;
+    ll rt = ceil(sqrt(n)) + 1;
+    vector<bool> primes(rt + 1), seg_sieve(n - m + 1);
+    for (ll i = 2; i <= rt; ++i) {
+        if (primes[i]) continue;
+        for (ll j = i + i; j <= rt; j += i)
+            primes[j] = true;
+        for (ll j = max(2LL, (m + i - 1) / i) * i; j <= n; j += i)
+            seg_sieve[j - m] = true;
+    }
+    return 0;
+}

subsequenceDivisibility.cpp

@@ -0,0 +1,29 @@
+//given a number having N digits, find number of subsequences of the number divisible by D
+//Time Complexity : O(nd)
+//Space Complexity : O(1)
+#include <bits/stdc++.h>
+#define ll long long int
+#define d 8
+using namespace std;
+
+int main() {
+    ll n,i,r;
+    ll cnst = 1e9 + 7;
+    cin>>n;
+    int dp[2][d] = {0};
+    char s[n+5];
+    cin>>s;
+    dp[0][0] = 1;
+    for(i=0;i<n;i++) {
+        for(r=0;r<d;r++) {
+            dp[1][(10*r + int(s[i]-'0'))%d] = (dp[1][(10*r + int(s[i]-'0'))%d] + dp[0][r])%cnst;
+            dp[1][r] = (dp[1][r] + dp[0][r])%cnst;
+        }
+        for(r=0;r<d;r++) {
+            dp[0][r] = dp[1][r];
+            dp[1][r] = 0;
+        }
+    }
+    cout<<dp[0][0] - 1;
+    return 0;
+}

unionOfIntervals.cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+struct interval {
+    int s;
+    int e;
+};
+
+bool comp(interval a, interval b)   {
+    return a.s>b.s;
+}
+
+void mergeIntervals(vector<interval> &a, int n) {
+    sort(a.begin(),a.end(),comp);
+    int index = 0;
+
+    for(int i=0;i<n;i++)    {
+        if(index != 0 && a[index-1].s <= a[i].e)    {
+            while(index != 0 && a[index-1].s <= a[i].e) {
+                a[index-1].s = min(a[index-1].s, a[i].s);
+                a[index-1].e = max(a[index-1].e, a[i].e);
+                index--;
+            }
+        }
+        else    {
+            a[index] = a[i];
+        }
+        index++;
+    }
+    for(int i=0;i<index;i++)
+        cout<<a[i].s<<" "<<a[i].e<<"\n";
+}
+
+int main()  {
+    int n;
+    cin>>n;
+    vector<interval> a(n);
+    for(int i=0;i<n;i++)
+        cin>>a[i].s>>a[i].e;
+    mergeIntervals(a,n);
+    return 0;
+}