From d13e297dd14a187b9a30bd080735415887547c08 Mon Sep 17 00:00:00 2001
From: dobhsh <shuchitadobhal@gmail.com>
Date: Wed, 2 Oct 2019 16:35:35 +0530
Subject: [PATCH 1/4] Added Shortest Path Algos for Graphs

---
 Graphs/Shortest Path Algos/bellman.cpp        | 69 +++++++++++++
 Graphs/Shortest Path Algos/dijikstra.cpp      | 89 +++++++++++++++++
 Graphs/Shortest Path Algos/floyd_warshall.cpp | 99 +++++++++++++++++++
 3 files changed, 257 insertions(+)
 create mode 100644 Graphs/Shortest Path Algos/bellman.cpp
 create mode 100644 Graphs/Shortest Path Algos/dijikstra.cpp
 create mode 100644 Graphs/Shortest Path Algos/floyd_warshall.cpp

diff --git a/Graphs/Shortest Path Algos/bellman.cpp b/Graphs/Shortest Path Algos/bellman.cpp
new file mode 100644
index 0000000..600f750
--- /dev/null
+++ b/Graphs/Shortest Path Algos/bellman.cpp	
@@ -0,0 +1,69 @@
+#include<iostream>
+#include<bits/stdc++.h>
+using namespace std;
+int e,v;
+struct edge
+{
+	char v1,v2;
+	int w;
+}*E;
+struct vertex
+{
+	char v,P;
+	int d;
+}*V;
+bool BellmanFord(char s)
+{
+	V[s-97].d=0;
+	for(int j=1;j<v;j++)
+	{
+		for(int i=0;i<e;i++)
+		{
+			if(E[i].w+V[(E[i].v1)-97].d<V[(E[i].v2)-97].d)
+			{
+				V[(E[i].v2)-97].P=E[i].v1;
+				V[(E[i].v2)-97].d=E[i].w+V[(E[i].v1)-97].d;
+			}
+		}
+	}
+	for(int i=0;i<e;i++)
+	{
+		if(E[i].w+V[(E[i].v1)-97].d<V[(E[i].v2)-97].d)
+		return false;
+	}
+	return true;
+}
+int main()
+{
+	char s;
+	cout<<"Enter no. of vertices: ";
+	cin>>v;
+	V=new vertex[v];
+	cout<<"Enter no. of edges: ";
+	cin>>e;
+	E=new edge[e];
+	cout<<"Enter edges and their weights: \n";
+	for(int i=0;i<e;i++)
+		cin>>E[i].v1>>E[i].v2>>E[i].w;
+	for(int i=0;i<v;i++)
+	{
+		V[i].v=i+97;
+		V[i].d=INT_MAX;
+		V[i].P=' ';
+	}
+	cout<<"Enter the souce vertex: ";
+	cin>>s;
+	bool res=BellmanFord(s);
+	if(res==false)
+	{
+		cout<<"Negative weight cycle exists in graph!!!\n";
+		cout<<"Bellman Ford Algorithm Fails!!!";
+	}
+	else
+	{
+		cout<<"Shortest Distance from "<<s<<":\n";
+		for(int i=0;i<v;i++)
+		cout<<V[i].v<<" = "<<" \t "<<V[i].d<<endl;
+	}
+	return 0;
+}
\ No newline at end of file
diff --git a/Graphs/Shortest Path Algos/dijikstra.cpp b/Graphs/Shortest Path Algos/dijikstra.cpp
new file mode 100644
index 0000000..6920396
--- /dev/null
+++ b/Graphs/Shortest Path Algos/dijikstra.cpp	
@@ -0,0 +1,89 @@
+#include<iostream>
+using namespace std;
+int e,v;
+char *Q;
+struct edge
+{
+	char v1,v2;
+	int w;
+}*E;
+struct vertex
+{
+	char v,P;
+	int d;
+}*V;
+char Extract_Min()
+{
+	char min;
+	int k=INT_MAX;
+	int pos;
+	for(int i=0;i<v;i++)
+	{
+		if(k>V[i].d&&Q[i]!=' ')
+		{
+			min=Q[i];
+			pos=i;
+			k=V[i].d;
+		}
+	}
+	Q[pos]=' ';
+	return min;
+}
+void dijkstra(char s)
+{
+	int qs=v;
+	char u,r=Q[s-97];
+	V[s-97].d=0;
+	while(qs--)
+	{
+		u=Extract_Min();
+		//cout<<u<<" ";
+		for(int i=0;i<e;i++)
+		{
+			if(E[i].v1==u)
+			{
+				if((Q[(E[i].v2)-97]!=' ')&&((E[i].w+V[u-97].d)<V[(E[i].v2)-97].d))
+				{
+					V[(E[i].v2)-97].P=E[i].v1;
+					V[(E[i].v2)-97].d=E[i].w+V[u-97].d;
+				}
+			}
+			else if(E[i].v2==u)
+			{
+				if((Q[(E[i].v1)-97]!=' ')&&((E[i].w+V[u-97].d)<V[(E[i].v1)-97].d))
+				{
+					V[(E[i].v1)-97].P=E[i].v2;
+					V[(E[i].v1)-97].d=E[i].w+V[u-97].d;
+				}
+			}
+		}
+	}
+}
+int main()
+{
+	char s;
+	cout<<"Enter no. of vertices: ";
+	cin>>v;
+	V=new vertex[v];
+	Q=new char[v];
+	cout<<"Enter no. of edges: ";
+	cin>>e;
+	E=new edge[e];
+	cout<<"Enter edges and their weights: \n";
+	for(int i=0;i<e;i++)
+	cin>>E[i].v1>>E[i].v2>>E[i].w;
+	for(int i=0;i<v;i++)
+	{
+		V[i].v=i+97;
+		V[i].d=INT_MAX;
+		V[i].P=' ';
+		Q[i]=i+97;		
+	}	
+	cout<<"Enter the souce vertex: ";
+	cin>>s;
+	dijkstra(s);
+	cout<<"Shortest Distance from "<<s<<":\n";
+	for(int i=0;i<v;i++)
+	cout<<V[i].v<<" = "<<" \t "<<V[i].d<<endl;
+	return 0;
+}
diff --git a/Graphs/Shortest Path Algos/floyd_warshall.cpp b/Graphs/Shortest Path Algos/floyd_warshall.cpp
new file mode 100644
index 0000000..33eab5e
--- /dev/null
+++ b/Graphs/Shortest Path Algos/floyd_warshall.cpp	
@@ -0,0 +1,99 @@
+#include<iostream>
+#include<climits>
+#include<bits/stdc++.h>
+using namespace std;
+int v,e;
+int **W;
+struct matrix
+{
+	int **D;
+	char **P;
+}*R;
+void Floyd_Warshall(int **W,int n)
+{
+	R=new matrix[n+1];
+	for(int i=0;i<=n;i++)
+	{
+		R[i].D=new int*[n];
+		R[i].P=new char*[n];
+		for(int k=0;k<n;k++)
+		{
+			R[i].D[k]=new int[n];
+			R[i].P[k]=new char[n];
+		}
+	}
+	for(int i=0;i<n;i++)
+	{
+		for(int j=0;j<n;j++)
+		{
+			R[0].D[i][j]=W[i][j];
+			if(W[i][j]==INT_MAX||W[i][j]==0)
+			R[0].P[i][j]='N';
+			else
+			R[0].P[i][j]=i+97;
+		}
+	}
+	for(int k=1;k<=n;k++)
+	{
+		for(int i=0;i<n;i++)
+		{
+			for(int j=0;j<n;j++)
+			{
+				if(R[k-1].D[i][j]>(R[k-1].D[i][k-1]+R[k-1].D[k-1][j])&&
+				   R[k-1].D[i][k-1]!=INT_MAX&&R[k-1].D[k-1][j]!=INT_MAX)
+				{
+					R[k].D[i][j]=R[k-1].D[i][k-1]+R[k-1].D[k-1][j];
+					R[k].P[i][j]=R[k-1].P[k-1][j];
+				}
+				else
+				{
+					R[k].D[i][j]=R[k-1].D[i][j];
+					R[k].P[i][j]=R[k-1].P[i][j];
+				}
+			}
+		}
+	}
+}
+int main()
+{
+	char a,b;
+	int w;
+	cout<<"Enter the no. of vertices: ";
+	cin>>v;
+	W=new int*[v];
+	cout<<"Enter the no. of edges: ";
+	cin>>e;
+	for(int i=0;i<v;i++)
+	{
+		W[i]=new int[v];
+		for(int j=0;j<v;j++)
+		{
+			if(i==j)
+			W[i][j]=0;
+			else
+			W[i][j]=INT_MAX;
+		}
+	}
+	cout<<"Enter edges and their corresponding weights: \n";
+	for(int i=0;i<e;i++)
+	{
+		cin>>a>>b>>w;
+		W[a-97][b-97]=w;
+	}
+	Floyd_Warshall(W,v);
+	cout<<"Distance Matrix: \n";
+	for(int i=0;i<v;i++)
+	{
+		for(int j=0;j<v;j++)
+		cout<<R[v].D[i][j]<<"\t";
+		cout<<endl;
+	}
+	cout<<"Parent Matrix: \n";
+	for(int i=0;i<v;i++)
+	{
+		for(int j=0;j<v;j++)
+		cout<<R[v].P[i][j]<<"\t";
+		cout<<endl;
+	}
+	return 0;
+}

From b9f85bcd504cf1b5a8a0d214ede789227e4e94dc Mon Sep 17 00:00:00 2001
From: dobhsh <shuchitadobhal@gmail.com>
Date: Thu, 3 Oct 2019 20:40:05 +0530
Subject: [PATCH 2/4] 4 programs

---
 Greedy/huffman coding.cpp | 44 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 Greedy/huffman coding.cpp

diff --git a/Greedy/huffman coding.cpp b/Greedy/huffman coding.cpp
new file mode 100644
index 0000000..921e8fd
--- /dev/null
+++ b/Greedy/huffman coding.cpp	
@@ -0,0 +1,44 @@
+#include<iostream>
+#include<string>
+#include<algorithm>
+
+using namespace std;
+sturct node{
+    int freq,sysindex;
+    char *binarycode;
+    char *left, *right;
+}*Q[50];
+
+int m=0;
+char *lstring, *rstring;
+node *Extract_Min(){
+    node *min=Q[m++];
+    return min;
+}
+
+void insertqueue(node *root, int qs){
+    int pos=qs;
+    for(int i=m;i<qs;i++){
+        if(Q[i]->freq > root->freq){
+            pos=i;
+            break;
+        }
+    }
+    for(i=qs;i>pos;i--){
+        Q[i]=Q[i-1];
+    }
+
+    Q[pos}=root;
+    qs++;
+}
+
+void generatecode(node *root, char *code[50], int n){
+    if(root->left==NULL){
+        code[root->sysindex]=new char[n];
+        strcpy(code[root->sysindex],root->binarycode);
+    }
+    else{
+        strcpy()
+
+    }
+}

From d402297e58221106e046e99edb06e26f64812535 Mon Sep 17 00:00:00 2001
From: dobhsh <shuchitadobhal@gmail.com>
Date: Thu, 3 Oct 2019 20:40:43 +0530
Subject: [PATCH 3/4] MST

---
 Graphs/Minimum Spanning Tree/kruskal.cpp | 55 +++++++++++++++
 Graphs/Minimum Spanning Tree/prims.cpp   | 88 ++++++++++++++++++++++++
 2 files changed, 143 insertions(+)
 create mode 100644 Graphs/Minimum Spanning Tree/kruskal.cpp
 create mode 100644 Graphs/Minimum Spanning Tree/prims.cpp

diff --git a/Graphs/Minimum Spanning Tree/kruskal.cpp b/Graphs/Minimum Spanning Tree/kruskal.cpp
new file mode 100644
index 0000000..175f1a9
--- /dev/null
+++ b/Graphs/Minimum Spanning Tree/kruskal.cpp	
@@ -0,0 +1,55 @@
+#include<iostream>
+#include<algorithm>
+#include"disjoint.h"
+using namespace std;
+struct edge
+{
+	char v1,v2;
+	int w;
+}*E,*MST;
+int v,e,t,*rank;
+char *P;
+bool comp(edge e1,edge e2)
+{
+	return (e1.w<e2.w);
+}
+void MST_kruskal()
+{
+	t=0;
+	MST=new edge[v-1];
+	sort(E,E+e,comp);
+	for(int i=0;i<e;i++)
+	{
+		if(find_set(E[i].v1,P,rank)!=find_set(E[i].v2,P,rank))
+		{
+			MST[t++]=E[i];
+			union_set(E[i].v1,E[i].v2,P,rank);
+		}
+	}
+}
+int main()
+{
+	char a,b;
+	cout<<"Enter no. of vertices: ";
+	cin>>v;
+	cout<<"Enter no. of edges: ";
+	cin>>e;
+	P=new char[v];
+	rank=new int[v];
+	cout<<"Enter the end vertices of the edges and their corresponding weights: \n";
+	E=new edge[e];
+	for(int i=0;i<v;i++)
+	P[i]=' ';
+	for(int i=0;i<e;i++)
+	{
+		cin>>E[i].v1>>E[i].v2>>E[i].w;
+		makeset(E[i].v1,P,rank);
+		makeset(E[i].v2,P,rank);
+	}
+	MST_kruskal();	
+	cout<<"Resultant Minimum Spanning Tree: \n";
+	cout<<"Edge \t"<<" Weight\n";
+	for(int i=0;i<t;i++)
+	cout<<MST[i].v1<<"---"<<MST[i].v2<<"  \t  "<<MST[i].w<<endl;
+	return 0;
+}
diff --git a/Graphs/Minimum Spanning Tree/prims.cpp b/Graphs/Minimum Spanning Tree/prims.cpp
new file mode 100644
index 0000000..525cdb7
--- /dev/null
+++ b/Graphs/Minimum Spanning Tree/prims.cpp	
@@ -0,0 +1,88 @@
+#include<iostream>
+#include<climits>
+using namespace std;
+int e,v;
+char *Q;
+struct edge
+{
+	char v1,v2;
+	int w;
+}*E;
+struct vertex
+{
+	char v,P;
+	int key;
+}*V;
+char Extract_Min()
+{
+	char min;
+	int k=INT_MAX;
+	int pos;
+	for(int i=0;i<v;i++)
+	{
+		if(k>V[i].key&&Q[i]!=' ')
+		{
+			min=Q[i];
+			pos=i;
+			k=V[i].key;
+		}
+	}
+	Q[pos]=' ';
+	return min;
+}
+void MST_Prim()
+{
+	int qs=v;
+	char u;
+	V[0].key=0;
+	while(qs--)
+	{
+		u=Extract_Min();
+		//cout<<u<<" ";
+		for(int i=0;i<e;i++)
+		{
+			if(E[i].v1==u)
+			{
+				if((Q[(E[i].v2)-97]!=' ')&&(E[i].w<V[(E[i].v2)-97].key))
+				{
+					V[(E[i].v2)-97].P=E[i].v1;
+					V[(E[i].v2)-97].key=E[i].w;
+				}
+			}
+			else if(E[i].v2==u)
+			{
+				if((Q[(E[i].v1)-97]!=' ')&&(E[i].w<V[(E[i].v1)-97].key))
+				{
+					V[(E[i].v1)-97].P=E[i].v2;
+					V[(E[i].v1)-97].key=E[i].w;
+				}
+			}
+		}
+	}
+}
+int main()
+{
+	cout<<"Enter no. of vertices: ";
+	cin>>v;
+	V=new vertex[v];
+	Q=new char[v];
+	cout<<"Enter no. of edges: ";
+	cin>>e;
+	E=new edge[e];
+	cout<<"Enter edges and their weights: \n";
+	for(int i=0;i<e;i++)
+	cin>>E[i].v1>>E[i].v2>>E[i].w;
+	for(int i=0;i<v;i++)
+	{
+		V[i].v=i+97;
+		V[i].key=INT_MAX;
+		V[i].P=' ';
+		Q[i]=i+97;		
+	}	
+	MST_Prim();
+	cout<<"Resultant Minimum Spanning Tree: \n";
+	cout<<"Edge \t"<<" Weight\n";
+	for(int i=1;i<v;i++)
+	cout<<V[i].v<<"---"<<V[i].P<<" \t "<<V[i].key<<endl;
+	return 0;
+}

From cf186053bd7b42049038317129ba8d51e64b5118 Mon Sep 17 00:00:00 2001
From: dobhsh <shuchitadobhal@gmail.com>
Date: Thu, 3 Oct 2019 20:41:00 +0530
Subject: [PATCH 4/4] MST

---
 Dynamic Programming/Medium/matrixchain.cpp | 62 ++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 Dynamic Programming/Medium/matrixchain.cpp

diff --git a/Dynamic Programming/Medium/matrixchain.cpp b/Dynamic Programming/Medium/matrixchain.cpp
new file mode 100644
index 0000000..a12d4c3
--- /dev/null
+++ b/Dynamic Programming/Medium/matrixchain.cpp	
@@ -0,0 +1,62 @@
+#include<iostream>
+#include<bits/stdc++.h>
+using namespace std;
+int **m,**s;
+void MatrixChainOrder(int *P,int n)
+{
+	int j;
+	long int q;
+	m=new int*[n];
+	s=new int*[n];
+	for(int i=0;i<n;i++)
+	{
+		m[i]=new int[n];
+		s[i]=new int[n];
+		m[i][i]=0;
+	}
+	for(int l=2;l<=n;l++)
+		for(int i=0;i<n-l+1;i++)
+		{
+			j=i+l-1;
+			m[i][j]=INT_MAX;
+			for(int k=i;k<j;k++)
+			{
+				q=m[i][k]+m[k+1][j]+(P[i]*P[k+1]*P[j+1]);
+				if(q<m[i][j])
+				{
+					m[i][j]=q;
+					s[i][j]=k;
+				}
+			}
+		}
+}
+int num=1;
+void disp(int a,int b)
+{
+	if(a==b)
+	{
+		cout<<"M"<<num;
+		num++;
+		return;	
+	}
+	cout<<"(";
+	disp(a,s[a][b]);
+	cout<<" X ";
+	disp(s[a][b]+1,b);
+	cout<<")";
+}
+int main()
+{
+	int n,*P;
+	cout<<"Enter the no. of matrices: ";
+	cin>>n;
+	P=new int[n+1];
+	cout<<"Enter the different orders: \n";
+	for(int i=0;i<n+1;i++)
+	cin>>P[i];
+	MatrixChainOrder(P,n);
+	cout<<"Order of Matrix Multiplication: \n";
+	disp(0,n-1);
+	cout<<"\nThe maximum scalar multiplications required: "<<m[0][n-1];
+	return 0;
+}
\ No newline at end of file