INIT

Author: nisarg0

Bit-mask/Bitmask_Basic.cpp

@@ -0,0 +1,41 @@
+// Reference -> https://www.youtube.com/watch?v=7FmL-WpTTJ4
+// We are using bitmask to store the numbers between 1 and 10 (in integers)
+// left shifting (x<<y) is equivalent to multiplying x with 2^y 
+// right shifting (x>>y) is equivalent to dividing x with 2^y. 
+
+#include<bits/stdc++.h>
+
+using namespace std;
+
+// If element is present it will get deleted and if its not there it will get added
+void erase_or_add(int n, int& subset)
+{
+    subset = subset ^ 1<<(n-1);
+}
+void display(int subset)
+{
+    cout<<"The subset is: ";
+    // i is the ith bit from right to left 
+    // 0th  bit represents 1
+    for(int i=0;i<9;i++)
+    {
+        if(1<<i&subset)
+            cout << i+1<<" ";
+    }
+    cout<<"\n";
+}
+
+int main()
+{
+    // num represents subset of numbers from 1 to 10
+    int num = 15;
+    display(num);
+    // delete the d from subset num
+    int d = 4;
+    erase_or_add(d,num);
+    display(num);
+
+    d=9;
+    erase_or_add(d,num);
+    display(num);
+}

DP/LIS.cpp

@@ -0,0 +1,82 @@
+/*
+Longest Increasing Subsequence
+Complexity for LIS Algo -> O(NlogN)  
+N-number of elements
+*/
+
+#include<bits/stdc++.h>
+using namespace std;
+
+// NOTE : aux is not necesserily the LIS but its length is same as LIS
+int length_LIS(int arr[], int n)
+{
+    vector<int> aux;    //auxiliary vector stores the array elements likely to be LIS 
+    for(int i = 0; i < n; i++) 
+    {
+        // Change lower_bound to upper_bound for non-decreasing subsequence 
+        auto itr = lower_bound(aux.begin(), aux.end(), arr[i]);
+        if (itr == aux.end()) 
+            aux.push_back(arr[i]); // No element is larger than arr[i]
+        else 
+            *itr = arr[i]; // replace the element in aux with elemwnt just smaller than it.
+    }
+  return aux.size();
+
+} 
+
+void find_LIS(int arr[],int n)
+{
+    vector<int> aux(n, 0);
+	vector<vector<int>> parent(n);
+
+	aux[0] = arr[0];
+
+	parent[0].push_back(arr[0]);
+	int aux_size = 1;
+	for (int i = 1; i < n; i++) 
+    {
+
+		auto it =lower_bound(aux.begin(), aux.begin() + aux_size, arr[i]);
+
+		if (it == aux.begin() + aux_size) 
+        {
+			aux[aux_size] = arr[i];
+						
+			parent[aux_size] = parent[aux_size - 1];
+			parent[aux_size].push_back(arr[i]);
+			aux_size++;
+		}
+		else 
+        {
+			if (*it != arr[i]) {
+				aux[it- aux.begin()] = arr[i];
+				
+				parent[it - aux.begin()][parent[it - aux.begin()].size() - 1] = arr[i];
+			}
+		}
+
+	}
+
+	cout << "length " << aux_size << endl;
+
+	for (auto x : parent[aux_size - 1]) {
+		cout << x << " ";
+	}
+}
+ 
+int main()
+{
+    int arr[] = { 10, 22, 9, 33, 21, 50, 41, 60 };
+    int n= sizeof(arr)/sizeof(int);
+    
+    // Strictly increasing sub sequence
+    cout << "Length of LIS is :" << length_LIS(arr,n) << endl;
+
+    // Print the LIS
+    find_LIS(arr,n);
+}
+
+// Intersting question :
+// Given arr1[N], arr2[M]   1<M<N<10^5
+// Find minimum elements you need to add in arr1 such that arr2 is a subsequence of arr1?
+// Soln: Codenation 1 april 2020 : hint(use maps, LIS)

DP/digit_dp.cpp

@@ -0,0 +1,47 @@
+// Reference -> https://www.youtube.com/watch?v=heUFId6Qd1A
+// F(x) returns boolean value
+// General -> How many integers x in range [0,R] obey F(x)
+// Example -> Find cnt of numbers betn L and R which have a sum of digits = x
+// 1 <= L <= R <= 10^18
+// 1 <= X <= 180
+#include<bits/stdc++.h>
+using namespace std;
+
+// Max no of dights in a number be 100(Not needed)
+int dp[101][181][2];
+// boolena value tight stores checks if we can place any number at indx(R.size()-n) or we need we can place till ub
+int digit_dp(string R,int n,int sum,bool tight)
+{
+    if(sum < 0)
+        return 0;
+    if(n==0)
+    {
+        if(sum == 0)
+            return 1;
+        return 0;
+    }
+
+    if(dp[n][sum][tight] != -1)
+        return dp[n][sum][tight];
+
+    // ub is upper bound till which digit we can use at that particular index
+    int ub = 9,ans=0;
+    if(tight)
+        ub = (R[R.size()-n]-'0');
+    for(int i=0;i<=ub;i++)
+    {
+        // Once a number is non tight it won't ever be tight in future
+        // A tight will be tight only if we keep on passing the higest number possible at that indx
+        ans += digit_dp(R,n-1,sum-i,tight&(i==ub));
+    }
+    return dp[n][sum][tight] = ans;
+}
+
+int main()
+{
+    string L = "";
+    string R = "490447834749";
+    int x = 20;
+    memset(dp,-1,sizeof dp);
+    cout<<digit_dp(R,R.size(),x,1);
+}

DP/travelling_salesman_prob.cpp

@@ -0,0 +1,52 @@
+// Reference -> https://www.youtube.com/watch?v=QukpHtZMAtM&list=PLb3g_Z8nEv1icFNrtZqByO1CrWVHLlO5g&index=4
+// Reference -> https://www.thecrazyprogrammer.com/2017/05/travelling-salesman-problem.html
+// Time Complexcity -> O(n^2 * 2^n)
+// Space Complexcity -> O(2^n * n)
+// NOTE : Whenever we feel a need to pass a subset of set we can use this technique of digit dp
+// Que. Find minimum distance to travel if travellers wishes to visit every city atleast once and reach back to his starting location at the end
+#include<bits/stdc++.h>
+using namespace std;
+
+#define MAX 9999
+
+int n=4; // Number of the places want to visit
+
+ //Next distan array will give Minimum distance through all the position
+int distan[10][10] = {                
+                    {0, 10, 15, 20},
+                    {10, 0, 35, 25},
+                    {15, 35, 0, 30},
+                    {20, 25, 30, 0}
+};
+
+int all_visited = (1<<n) -1;
+int dp[16][4];
+
+
+int  TSP(int visited,int position)
+{
+    // Initially checking whether all the places are visited or not
+    if(visited==all_visited)
+        return distan[position][0];
+
+    if(dp[visited][position]!=-1)
+        return dp[visited][position];
+    
+    // init
+    int answer = MAX;
+
+    // chack for each city
+    for(int city=0;city<n;city++)
+        if((visited&(1<<city))==0)  // is the city visited check
+            answer = min(answer, distan[position][city] + TSP( visited|(1<<city),city));
+
+    return dp[visited][position] = answer;
+}
+
+int main()
+{
+    memset(dp,-1,sizeof dp);
+    cout<<"Minimum Distance Travelled by traveller is "<<TSP(1,0);
+
+    return 0;
+}

Graph/BFS.cpp

@@ -0,0 +1,70 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+#define LIM 1007
+
+vector<int> adj[LIM];
+// vector<int> dist(LIM,-1);
+// vector<int> parent(LIM,-1);
+int visited[LIM];
+
+void addEdge(int u, int v) 
+{ 
+    adj[u].push_back(v);
+    adj[v].push_back(u);
+} 
+
+void bfs(int src)
+{
+    queue<int> q;
+    int d=0;
+    // dist[src] = d;
+    // parent[src] = -1;
+    q.push(src);
+    visited[src]=true;
+    while(!q.empty())
+    {
+        int u = q.front();
+        q.pop();
+
+        cout<<u<<" ";
+        for(int v : adj[u])
+        {
+            if(!visited[v])
+            {
+                // dist[v] = dist[u] + 1;
+                // parent[v] = u;
+                
+                visited[v]=true;    //NOTE : We put visited here inside the inner loop
+                q.push(v);
+            }
+                
+        }
+    }
+}
+
+
+int main()
+{
+    int V,i,src,u,v,wt,E;
+
+    cout<<"Enter number of vertices and edges: ";
+    cin>>V>>E;
+    
+
+    for(i=0;i<E;i++)
+    {
+        cout<<i+1<<". Enter vertex name u and v:  ";
+        cin>>u>>v;
+        addEdge(u,v);
+    }
+   
+
+    cout<<"Enter source node for iterative bfs: ";
+    cin>>src;
+    cout<<"BFS=> ";
+    bfs(src);
+    cout<<endl;
+
+
+}

Graph/Bellman_ford(Negative_weights).cpp

@@ -0,0 +1,83 @@
+/*
+Reference -> https://www.youtube.com/watch?v=FtN3BYH2Zes
+Minimum distance of src from every other node present in graph
+Complexity for Bellman Ford's Algo -> O(E*V)  
+E-Edges V-Vertices
+*/
+#include<bits/stdc++.h>
+#define LIM 3000
+#define INF 1e5+3
+
+using namespace std;
+
+
+//NOTE: Here reprentation of graph is done a bit differnetly 
+typedef pair<int,int> pii;
+
+vector<vector<int>> G(LIM,vector<int>(3));
+vector<int> min_dist(LIM,INF);
+int V,E;
+
+/*
+IMP NOTE: If there is a cycle with total sum negative then this algo WON'T WORK
+We baically relax the edges V-1 times
+*/
+void bellman_ford(int src)
+{
+    min_dist[src] = 0;
+    int u,v,k;
+    for(k=0;k<V-1;k++)
+    {
+        for(auto itr : G)
+        {
+            int u = itr[0];
+            int v = itr[1];
+            int wt = itr[2];
+
+            min_dist[v] = min(min_dist[v],min_dist[u]+wt);
+        }
+    }
+
+    // If the min min_dist is still changing even after V-1 iterstions means there is no soln.
+    for(auto itr : G)
+    {
+        int u = itr[0];
+        int v = itr[1];
+        int wt = itr[2];
+
+        if(min_dist[v] > min_dist[u]+wt)
+        {
+            cout << "There is a negtive cycle\n";
+            break;
+        }
+    }
+    
+}
+
+int main()
+{
+    int i,src=0,u,v,wt;
+
+    cout<<"Enter number of vertices and edges: ";
+    cin>>V>>E;
+    cout<<endl;
+
+    for(i=0;i<8;i++)
+    {
+        cout<<"Enter vertex name u , v and weight: ";
+        cin>>u>>v>>wt;
+
+        G[i][0] = u;
+        G[i][1] = v;
+        G[i][2] = wt;
+    }
+    
+    cout<<"Enter the source node: ";
+    cin>>src;
+    bellman_ford(src);
+    cout<<endl;
+
+    cout<<"Min distace all nodes from "<<src<<"is:\n";
+    for(int i=0;i<V;i++)
+        cout<<i<<" : "<<min_dist[i]<<endl;
+}