Merge pull request #16 from ghost/master

added tree traversals and c++ snippets

Author: GouravSingh2580

Graphs1/BFS_for_finding_distance_of_every_node_from_root.cpp

@@ -0,0 +1,104 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+#define int long long int
+#define ll long long
+#define quickie ios_base::sync_with_stdio(false); cin.tie(NULL);
+#define rep(i, a, b) for(int i=a; i<b; i++)
+#define rep1(i, a, b) for(int i=a; i<=b; i++)
+#define repp(i, a, b) for(int i=b-1; i>=a; i--)
+#define pb push_back
+#define mp make_pair
+#define fi first
+#define se second
+#define SZ(x) ((int)(x).size())
+#define db double
+#define mi map<int, int>
+#define vi vector<int>
+#define qi queue<int>
+#define MI(x) power(x, mod-2)
+#define test int t; cin >> t;
+#define all(a) a.begin(),a.end()
+#define mod 1000000007
+#define pi 3.141592653589
+#define fact(n) rep(i, 1, n+1)ft.pb((ft[i-1]*i)%mod) ;
+int power(int x, int y) ;
+int gcd(int a, int b) ;
+
+// #include <ext/pb_ds/assoc_container.hpp>
+// #include <ext/pb_ds/tree_policy.hpp>
+// using namespace __gnu_pbds;
+// template<typename T>
+// using ordered_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
+// template<typename T>
+// using ordered_multiset = tree<T,null_type,less_equal<T>,rb_tree_tag,tree_order_statistics_node_update>;
+//(*****FOR USING ORDERED SET CHANGE INT*******)
+
+// struct chash {
+// const int RANDOM = (long long)(make_unique<char>().get()) ^ chrono::high_resolution_clock::now().time_since_epoch().count();
+// static unsigned long long hash_f(unsigned long long x) {
+// x += 0x9e3779b97f4a7c15;
+// x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+// x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+// return x ^ (x >> 31);
+// }
+// static unsigned hash_combine(unsigned a, unsigned b) { return a * 31 + b; }
+// int operator()(int x) const { return hash_f(x)^RANDOM; }
+// };
+
+int power(int x, int y) ;
+int gcd(int a,int b) ; 
+
+vi v[100001] ;
+bool vis[100001] ;
+int dis[100001] ;
+
+void bfs(int root) {
+ qi q ;
+ q.push(root) ;
+ vis[root] = true ;
+ dis[root] = 0 ;
+ while(!q.empty()) {
+ int cur = q.front() ;
+ q.pop() ;
+ for(auto i : v[cur]) {
+ if(!vis[i]) {
+ q.push(i) ;
+ dis[i] = dis[cur]+1 ;
+ vis[i] = true ;
+ }
+ }
+ }
+}
+ 
+signed main() {
+ quickie
+ int n, m, root ;
+ cin >> n >> m >> root ;
+ rep(i, 0, m) {
+ int a, b ;
+ cin >> a >> b ;
+ v[a].pb(b) ;
+ v[b].pb(a) ;
+ }
+ bfs(root) ;
+ rep(i, 1, n+1) cout << dis[i] << " " ;
+ cout << "\n" ;
+}
+
+int power(int x, int y) {
+ int res = 1; x %= mod;
+ while (y > 0) {
+ if (y & 1)
+ res = (res*x) % mod;
+ y = y>>1;
+ x = (x*x) % mod;
+ }
+ return res%mod;
+}
+
+int gcd(int a,int b) {
+ if(a==0) return b;
+ return gcd(b%a,a);
+}
+

Graphs1/DFS.cpp

@@ -0,0 +1,43 @@
+
+ public:
+ Graph(int V);
+ void addEdge(int src, int dest);
+ void DFS(int vertex);
+};
+
+// Initialize graph
+Graph::Graph(int vertices) {
+ numVertices = vertices;
+ adjLists = new list<int>[vertices];
+ visited = new bool[vertices];
+}
+
+// Add edges
+void Graph::addEdge(int src, int dest) {
+ adjLists[src].push_front(dest);
+}
+
+// DFS algorithm
+void Graph::DFS(int vertex) {
+ visited[vertex] = true;
+ list<int> adjList = adjLists[vertex];
+
+ cout << vertex << " ";
+
+ list<int>::iterator i;
+ for (i = adjList.begin(); i != adjList.end(); ++i)
+ if (!visited[*i])
+ DFS(*i);
+}
+
+int main() {
+ Graph g(4);
+ g.addEdge(0, 1);
+ g.addEdge(0, 2);
+ g.addEdge(1, 2);
+ g.addEdge(2, 3);
+
+ g.DFS(2);
+
+ return 0;
+}

Graphs1/Kruskal MST.cpp

@@ -0,0 +1,72 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+class UnionFind //To check for a cycle in the graph.
+{
+ private: vector<int> p,rank;
+ public:
+ UnionFind(int N)
+ {
+ rank.assign(N,0);
+ p.assign(N,0);
+ 
+ for(int i=0;i<N;i++)
+ p[i]=i;
+ }
+ 
+ int findSet(int i) {return (p[i]==i) ? i : (p[i]=findSet(p[i]));}
+ 
+ bool isSameSet(int a, int b) {return findSet(a)==findSet(b);}
+ 
+ void unionSet(int a,int b)
+ {
+ if(!isSameSet(a,b))
+ {
+ int x=findSet(a);
+ int y=findSet(b);
+
+ if(rank[x]>rank[y]) {p[y]=x; rank[x]++;}
+ else
+ {
+ p[x]=y;
+ if(rank[x]==rank[y]) rank[y]++;
+ } 
+ }
+ }
+};
+
+int main()
+{
+ vector<pair< int, pair<int,int> > > EdgeList;
+ cout<<"Enter the number of vertices: \n";
+ int V;
+ cin>>V;
+ cout<<"Enter the number of edges: \n";
+ int E;
+ cin>>E;
+ cout<<"Enter the edges with their weights: (Vertex 1 Vertex 2 Weight)\n";
+ for(int i=0;i<E;i++)
+ {
+ int u,v,w;
+ cin>>u>>v>>w;
+ EdgeList.push_back(make_pair(w,make_pair(u,v)));
+ }
+ 
+ sort(EdgeList.begin(),EdgeList.end());
+
+ int weight=0;
+
+ UnionFind UF(V);
+
+ for(int i=0;i<E;i++)
+ {
+ pair< int, pair<int,int> > front=EdgeList[i];
+ if(!UF.isSameSet(front.second.first, front.second.second))
+ {
+ weight+=front.first;
+ UF.unionSet(front.second.first, front.second.second);
+ }
+ }
+ cout<<"Final Weight of the MST is: "<<weight;
+ return 0;
+}

Graphs1/Prims MST.cpp

@@ -0,0 +1,54 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+vector<int> taken;
+vector<vector<pair<int,int> > > AdjList;
+priority_queue<pair<int,int> > pq; //Max-Heap in C++ STL
+
+void process(int vtx)
+{
+ taken[vtx]=1;
+ for(int j=1; j<(int)AdjList[vtx].size(); j++)
+ {
+ pair<int,int> v=AdjList[vtx][j];
+ if(!taken[v.first]) pq.push(make_pair(-v.second,-v.first));
+ }
+}
+
+int main()
+{
+ cout<<"Enter the number of vertices: ";
+ int V;
+ cin>>V;
+ vector<pair<int,int> > temp(1,make_pair(-1,-1));
+ for(int i=0;i<V;i++) AdjList.push_back(temp);
+ cout<<"Enter the number of Edges: ";
+ int E;
+ cin>>E;
+ cout<<"Enter the edges with their weights: ";
+ for(int i=0; i<E; i++)
+ {
+ int u,v,w;
+ cin>>u>>v>>w;
+ AdjList[u].push_back(make_pair(v,w));
+ AdjList[v].push_back(make_pair(u,w));
+ }
+ taken.assign(V,0);
+ int weight=0;
+
+ process(0);
+ while(!pq.empty())
+ {
+ pair<int,int> p=pq.top();
+ pq.pop();
+ int u=-p.second;
+ int w=-p.first;
+
+ if(!taken[u])
+ weight+=w, process(u);
+ }
+ 
+ cout<<"The weight of the MST is: "<<weight;
+
+ return 0;
+}

Trees/Inorder Traversal.cpp

@@ -0,0 +1,39 @@
+#include<bits/stdc++.h>
+#include<iostream>
+using namespace std;
+
+struct Node 
+{ 
+ int data; 
+ struct Node* left, *right; 
+ Node(int data) 
+ { 
+ this->data = data; 
+ left = right = NULL; 
+ } 
+}; 
+
+void printInorder(struct Node* node) 
+{ 
+ if (node == NULL) 
+ return; 
+ 
+ printInorder(node->left); 
+ cout << node->data << " "; 
+ printInorder(node->right); 
+} 
+ 
+int main() 
+{ 
+ struct Node *root = new Node(1); 
+ root->left = new Node(2); 
+ root->right->left = new Node(3); 
+ root->left->left = new Node(4); 
+ root->left->right = new Node(5); 
+ 
+ cout << "\nInorder traversal of binary tree is \n"; 
+ printInorder(root); 
+ 
+ 
+ return 0; 
+}