diff --git a/Dynamic Programming/Bellman-Ford.cpp b/Dynamic Programming/Bellman-Ford.cpp
new file mode 100644
index 000000000..ca1cd49ef
--- /dev/null
+++ b/Dynamic Programming/Bellman-Ford.cpp	
@@ -0,0 +1,116 @@
+#include<iostream>
+#include<limits.h>
+
+using namespace std;
+
+//Wrapper class for storing an edge
+class Edge{
+	public: int src,dst,weight;
+};
+
+//Wrapper class for storing a graph
+class Graph{
+	public:
+	int vertexNum,edgeNum;
+	Edge* edges;
+
+	//Constructs a graph with V vertices and E edges
+	Graph(int V,int E){
+		this->vertexNum = V;
+		this->edgeNum = E;
+		this->edges =(Edge*) malloc(E * sizeof(Edge));
+	}
+
+	//Adds the given edge to the graph 
+	void addEdge(int src, int dst, int weight){
+		static int edgeInd = 0;
+		if(edgeInd < this->edgeNum){
+			Edge newEdge;
+			newEdge.src = src;
+			newEdge.dst = dst;
+			newEdge.weight = weight;
+			this->edges[edgeInd++] = newEdge;
+		}
+
+	}
+	
+};
+
+//Utility function to print distances
+void print(int dist[], int V){
+	cout<<"\nVertex  Distance"<<endl;
+	for(int i = 0; i < V; i++){
+		if( dist[i] != INT_MAX)
+			cout<<i<<"\t"<<dist[i]<<endl;
+		else
+			cout<<i<<"\tINF"<<endl;
+	}
+}
+
+//The main function that finds the shortest path from given source
+//to all other vertices using Bellman-Ford.It also detects negative
+//weight cycle
+void BellmanFord(Graph graph, int src){
+	int V = graph.vertexNum;
+	int E = graph.edgeNum;
+	int dist[V];
+
+	//Initialize distances array as INF for all except source
+	//Intialize source as zero
+	for(int i=0; i<V; i++)
+		dist[i] = INT_MAX;
+	dist[src] = 0;
+
+	//Calculate shortest path distance from source to all edges
+	//A path can contain maximum (|V|-1) edges
+	for(int i=0; i<=V-1; i++)
+		for(int j = 0; j<E; j++){
+			int u = graph.edges[j].src;
+			int v = graph.edges[j].dst;
+			int w = graph.edges[j].weight;
+			
+			if(dist[u]!=INT_MAX && dist[u] + w < dist[v])
+				dist[v] = dist[u] + w;
+		}
+	
+	//Iterate inner loop once more to check for negative cycle
+	for(int j = 0; j<E; j++){
+		int u = graph.edges[j].src;
+		int v = graph.edges[j].dst;
+		int w = graph.edges[j].weight;
+		
+		if(dist[u]!=INT_MAX && dist[u] + w < dist[v]){
+			cout<<"Graph contains negative weight cycle. Hence, shortest distance not guaranteed."<<endl;
+			return;
+		}
+	}
+
+	print(dist, V);
+	
+	return;
+}
+
+//Driver Function
+int main(){
+	int V,E,gsrc;
+	int src,dst,weight;
+	cout<<"Enter number of vertices: ";
+	cin>>V;
+	cout<<"Enter number of edges: ";
+	cin>>E;
+	Graph G(V,E);
+	for(int i=0; i<E; i++){
+		cout<<"\nEdge "<<i+1<<"\nEnter source: ";
+		cin>>src;
+		cout<<"Enter destination: ";
+		cin>>dst;
+		cout<<"Enter weight: ";
+		cin>>weight;
+		G.addEdge(src, dst, weight);
+	}
+	cout<<"\nEnter source: ";
+	cin>>gsrc;
+	BellmanFord(G,gsrc);
+
+	return 0;
+}
diff --git a/Dynamic Programming/Floyd-Warshall.cpp b/Dynamic Programming/Floyd-Warshall.cpp
new file mode 100644
index 000000000..9f037a64d
--- /dev/null
+++ b/Dynamic Programming/Floyd-Warshall.cpp	
@@ -0,0 +1,106 @@
+#include<iostream>
+#include<limits.h>
+#include<string.h>
+
+using namespace std;
+
+//Wrapper class for storing a graph
+class Graph{
+	public:
+	int vertexNum;
+	int** edges;
+
+	//Constructs a graph with V vertices and E edges
+	Graph(int V){
+		this->vertexNum = V;
+		this->edges =(int**) malloc(V * sizeof(int*));
+		for(int i=0; i<V; i++){
+			this->edges[i] = (int*) malloc(V * sizeof(int));
+			for(int j=0; j<V; j++)
+				this->edges[i][j] = INT_MAX;
+			this->edges[i][i] = 0;
+		}		
+	}
+
+	//Adds the given edge to the graph 
+	void addEdge(int src, int dst, int weight){
+		this->edges[src][dst] = weight;
+	}
+	
+
+};
+
+
+//Utility function to print distances
+void print(int dist[], int V){
+	cout<<"\nThe Distance matrix for Floyd - Warshall"<<endl;
+	for(int i = 0; i < V; i++){
+		for(int j=0; j<V; j++){
+
+		if(dist[i*V+j] != INT_MAX)	
+			cout<<dist[i*V+j]<<"\t";
+		else
+			cout<<"INF"<<"\t";
+		}
+		cout<<endl;
+	}
+}
+
+//The main function that finds the shortest path from a vertex
+//to all other vertices using Floyd-Warshall Algorithm.
+void FloydWarshall(Graph graph){
+	int V = graph.vertexNum;
+	int dist[V][V];
+	
+	//Initialise distance array
+	for(int i=0; i<V; i++)
+		for(int j=0; j<V; j++)
+			dist[i][j] = graph.edges[i][j];	
+			
+	
+	//Calculate distances
+	for(int k=0; k<V; k++)
+	//Choose an intermediate vertex
+
+		for(int i=0; i<V; i++)	
+		//Choose a source vertex for given intermediate
+
+			for(int j=0; j<V; j++)
+			//Choose a destination vertex for above source vertex
+
+				if(dist[i][k] != INT_MAX && dist[k][j] != INT_MAX && dist[i][k] + dist[k][j] < dist[i][j])
+				//If the distance through intermediate vertex is less than direct edge then update value in distance array
+					dist[i][j] = dist[i][k] + dist[k][j];
+
+	
+	//Convert 2d array to 1d array for print
+	int dist1d[V*V];	
+	for(int i=0; i<V; i++)
+		for(int j=0; j<V; j++)
+			dist1d[i*V+j] = dist[i][j];
+	
+	print(dist1d,V);	
+	}
+
+//Driver Function
+int main(){
+	int V,E;
+	int src,dst,weight;
+	cout<<"Enter number of vertices: ";
+	cin>>V;
+	cout<<"Enter number of edges: ";
+	cin>>E;
+	Graph G(V);
+	for(int i=0; i<E; i++){
+		cout<<"\nEdge "<<i+1<<"\nEnter source: ";
+		cin>>src;
+		cout<<"Enter destination: ";
+		cin>>dst;
+		cout<<"Enter weight: ";
+		cin>>weight;
+		G.addEdge(src, dst, weight);
+	}
+	FloydWarshall(G);
+
+	return 0;
+}
diff --git a/Greedy Algorithms/Dijkstra.cpp b/Greedy Algorithms/Dijkstra.cpp
new file mode 100644
index 000000000..e53f227c0
--- /dev/null
+++ b/Greedy Algorithms/Dijkstra.cpp	
@@ -0,0 +1,107 @@
+#include<iostream>
+#include<limits.h>
+
+using namespace std;
+
+//Wrapper class for storing a graph
+class Graph{
+	public:
+	int vertexNum;
+	int** edges;
+
+	//Constructs a graph with V vertices and E edges
+	Graph(int V){
+		this->vertexNum = V;
+		this->edges =(int**) malloc(V * sizeof(int*));
+		for(int i=0; i<V; i++)
+			this->edges[i] = (int*) calloc(V, sizeof(int));
+		
+	}
+
+	//Adds the given edge to the graph 
+	void addEdge(int src, int dst, int weight){
+		this->edges[src][dst] = weight;
+	}
+	
+
+};
+//Utility function to find minimum distance vertex in mdist
+int minDistance(int mdist[], bool vset[], int V){
+	int minVal = INT_MAX, minInd;
+	for(int i=0; i<V;i++)
+		if(vset[i] == false && mdist[i] < minVal){
+		minVal = mdist[i];
+		minInd = i;
+		}
+			
+	return minInd;
+}
+
+//Utility function to print distances
+void print(int dist[], int V){
+	cout<<"\nVertex  Distance"<<endl;
+	for(int i = 0; i < V; i++){
+		if( dist[i] != INT_MAX)
+			cout<<i<<"\t"<<dist[i]<<endl;
+		else
+			cout<<i<<"\tINF"<<endl;
+	}
+}
+
+//The main function that finds the shortest path from given source
+//to all other vertices using Dijkstra's Algorithm.It doesn't work on negative
+//weights
+void Dijkstra(Graph graph, int src){
+	int V = graph.vertexNum;
+	int mdist[V]; //Stores updated distances to vertex
+	bool vset[V]; // vset[i] is true if the vertex i included
+			 // in the shortest path tree
+
+	//Initialise mdist and vset. Set distance of source as zero
+	for(int i=0; i<V; i++)
+		mdist[i] = INT_MAX, vset[i] = false;
+	
+	mdist[src] = 0;
+	
+	//iterate to find shortest path
+	for(int count = 0; count<V-1; count++){
+		int u = minDistance(mdist,vset,V);
+		
+		vset[u] = true;
+		
+		for(int v=0; v<V; v++){
+			if(!vset[v] && graph.edges[u][v] && mdist[u] + graph.edges[u][v] < mdist[v])
+				mdist[v] = mdist[u] + graph.edges[u][v];
+				
+		}
+	}
+
+	print(mdist, V);
+	
+	return;
+}
+
+//Driver Function
+int main(){
+	int V,E,gsrc;
+	int src,dst,weight;
+	cout<<"Enter number of vertices: ";
+	cin>>V;
+	cout<<"Enter number of edges: ";
+	cin>>E;
+	Graph G(V);
+	for(int i=0; i<E; i++){
+		cout<<"\nEdge "<<i+1<<"\nEnter source: ";
+		cin>>src;
+		cout<<"Enter destination: ";
+		cin>>dst;
+		cout<<"Enter weight: ";
+		cin>>weight;
+		G.addEdge(src, dst, weight);
+	}
+	cout<<"\nEnter source:";
+	cin>>gsrc;
+	Dijkstra(G,gsrc);
+
+	return 0;
+}