Category Archives: Graph

It works on negative cycle.

Implemented Code:

Time Complexity:

O([E].[V])

Reference:
http://cyberlingo.blogspot.com/2015/07/bellman-ford-algorithm.html

Leave a comment

Posted in Algo Unsolved, Bellman Ford, Single Source Shortest Path

Tagged not greedy

Dijkstra

Posted on July 10, 2017 | Leave a comment

#include<bits/stdc++.h>
using namespace std;

int main(){
    int cost[10][10],path[10][10],i,j,n,p,v,min,index=1;
    int distance[10],row,column;

    cout<<"Enter no. of nodes: ";
    cin>>n;
    cout<<"Enter cost matrix: \n";
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=n;j++)
        {
            cin>>cost[i][j];
        }
    }
    printf("Enter the node you want to visit:");
    cin>>v;
    printf("Enter the path for the selected node:");
    cin>>p;
    cout<<"Enter the path matrix: \n";
    for(i=1;i<=p;i++)
    {
        for(j=1;j<=n;j++)
        {
            cin>>path[i][j];
        }
    }

    for(i=1;i<=p;i++){
        distance[i]=0;
        row=1;
        for(j=1;j<=n;j++)
        {
            if(row!=v)
            {
                column=path[i][j+1];
                distance[i]=distance[i]+cost[row][column];

            }
            row=column;

        }

    }
    min=distance[1];
for(i=1;i<=p;i++)
{
    if(distance[i]<=min)
    {
        min=distance[i];
        index=i;
    }
}
cout<<"The minimum distance is:";
cout<<min;
for(i=1;i<=n;i++){
    if(path[index][i]!=0)
    {
        printf("-->%d",path[index][i]);
    }
}

}

#include<bits/stdc++.h>

using namespace std;

int main(){

int cost[10][10],path[10][10],i,j,n,p,v,min,index=1;

int distance[10],row,column;

cout<<"Enter no. of nodes: ";

cin>>n;

cout<<"Enter cost matrix: \n";

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

{

cin>>cost[i][j];

}

printf("Enter the node you want to visit:");

cin>>v;

printf("Enter the path for the selected node:");

cin>>p;

cout<<"Enter the path matrix: \n";

for(i=1;i<=p;i++)

{

for(j=1;j<=n;j++)

{

cin>>path[i][j];

}

for(i=1;i<=p;i++){

distance[i]=0;

row=1;

for(j=1;j<=n;j++)

{

if(row!=v)

{

column=path[i][j+1];

distance[i]=distance[i]+cost[row][column];

}

row=column;

}

min=distance[1];

for(i=1;i<=p;i++)

{

if(distance[i]<=min)

{

min=distance[i];

index=i;

}

cout<<"The minimum distance is:";

cout<<min;

for(i=1;i<=n;i++){

if(path[index][i]!=0)

{

printf("-->%d",path[index][i]);

}

output:

Enter no. of nodes: 5
Enter cost matrix:
0
4
0
8
0
4
0
3
0
0
0
3
0
4
0
8
0
4
0
7
0
0
0
7
0
Enter the node you want to visit:5
Enter the path for the selected node:2
Enter the path matrix: 1
2
3
4
5
1
4
5
0
0
The minimum distance is:15-->1-->4-->5

Enter no. of nodes: 5

Enter cost matrix:

Enter the node you want to visit:5

Enter the path for the selected node:2

Enter the path matrix: 1

The minimum distance is:15-->1-->4-->5

Complexity:
O(E+V^2)

We are using here adjacency matrix list

Leave a comment

Posted in Dijkstra, Graph, Single Source Shortest Path

Topological Sort

Posted on July 10, 2017 | Leave a comment

code:

// A Java program to print topological sorting of a DAG
import java.io.*;
import java.util.*;

// This class represents a directed graph using adjacency
// list representation
class Graph
{
    private int V;   // No. of vertices
    private LinkedList<Integer> adj[]; // Adjacency List

    //Constructor
    Graph(int v)
    {
        V = v;
        adj = new LinkedList[v];
        for (int i=0; i<v; ++i)
            adj[i] = new LinkedList();
    }

    // Function to add an edge into the graph
    void addEdge(int v,int w) { adj[v].add(w); }

    // A recursive function used by topologicalSort
    void topologicalSortUtil(int v, boolean visited[],
                             Stack stack)
    {
        // Mark the current node as visited.
        visited[v] = true;
        Integer i;

        // Recur for all the vertices adjacent to this
        // vertex
        Iterator<Integer> it = adj[v].iterator();
        while (it.hasNext())
        {
            i = it.next();
            if (!visited[i])
                topologicalSortUtil(i, visited, stack);
        }

        // Push current vertex to stack which stores result
        stack.push(new Integer(v));
    }

    // The function to do Topological Sort. It uses
    // recursive topologicalSortUtil()
    void topologicalSort()
    {
        Stack stack = new Stack();

        // Mark all the vertices as not visited
        boolean visited[] = new boolean[V];
        for (int i = 0; i < V; i++)
            visited[i] = false;

        // Call the recursive helper function to store
        // Topological Sort starting from all vertices
        // one by one
        for (int i = 0; i < V; i++)
            if (visited[i] == false)
                topologicalSortUtil(i, visited, stack);

        // Print contents of stack
        while (stack.empty()==false)
            System.out.print(stack.pop() + " ");
    }

    // Driver method
    public static void main(String args[])
    {
        // Create a graph given in the above diagram
        Graph g = new Graph(6);
        g.addEdge(5, 2);
        g.addEdge(5, 0);
        g.addEdge(4, 0);
        g.addEdge(4, 1);
        g.addEdge(2, 3);
        g.addEdge(3, 1);

        System.out.println("Following is a Topological " +
                "sort of the given graph");
        g.topologicalSort();
    }
}

// A Java program to print topological sorting of a DAG

import java.io.*;

import java.util.*;

// This class represents a directed graph using adjacency

// list representation

class Graph

{

private int V; // No. of vertices

private LinkedList<Integer> adj[]; // Adjacency List

//Constructor

Graph(int v)

{

V = v;

adj = new LinkedList[v];

for (int i=0; i<v; ++i)

adj[i] = new LinkedList();

}

// Function to add an edge into the graph

void addEdge(int v,int w) { adj[v].add(w); }

// A recursive function used by topologicalSort

void topologicalSortUtil(int v, boolean visited[],

Stack stack)

{

// Mark the current node as visited.

visited[v] = true;

Integer i;

// Recur for all the vertices adjacent to this

// vertex

Iterator<Integer> it = adj[v].iterator();

while (it.hasNext())

{

i = it.next();

if (!visited[i])

topologicalSortUtil(i, visited, stack);

}

// Push current vertex to stack which stores result

stack.push(new Integer(v));

}

// The function to do Topological Sort. It uses

// recursive topologicalSortUtil()

void topologicalSort()

{

Stack stack = new Stack();

// Mark all the vertices as not visited

boolean visited[] = new boolean[V];

for (int i = 0; i < V; i++)

visited[i] = false;

// Call the recursive helper function to store

// Topological Sort starting from all vertices

// one by one

for (int i = 0; i < V; i++)

if (visited[i] == false)

topologicalSortUtil(i, visited, stack);

// Print contents of stack

while (stack.empty()==false)

System.out.print(stack.pop() + " ");

}

// Driver method

public static void main(String args[])

{

// Create a graph given in the above diagram

Graph g = new Graph(6);

g.addEdge(5, 2);

g.addEdge(5, 0);

g.addEdge(4, 0);

g.addEdge(4, 1);

g.addEdge(2, 3);

g.addEdge(3, 1);

System.out.println("Following is a Topological " +

"sort of the given graph");

g.topologicalSort();

}

Output:

Following is a Topological sort of the given graph
5 4 2 3 1 0

1 2	Following is a Topological sort of the given graph 5 4 2 3 1 0

Time Complexity: O(V+E)
Space Complexity: O(V)
V for vertex E for edge

code courtesy:

Topological Sorting

I understood the theory but need to understand the code well later

Leave a comment

Posted in Graph, Topological Sort

Algorithm: BFS(Breadth First Search)

Posted on May 26, 2017 | Leave a comment

Theory:

http://scanftree.com/Data_Structure/Breadth-First-Search

Bangla:

গ্রাফ থিওরিতে হাতেখড়ি-৪(ব্রেডথ ফার্স্ট সার্চ)

Video:

code implementation:

Some other links may help:

Breadth First Search Algorithm

code:

//bfs implementation for undirected unweighted graph
#include<fstream>
#include<queue>
#include<vector>
#include<iostream>
using namespace std;

int main()
{
    int n,m,start;
    int a,b;
    cin>>n>>m>>start;
    vector<int> samp;
    vector<vector<int> > conn(n+1,samp); //conn taking custom value in vector to make it sizeable

    //loading adjacency matrix
    for(int i=0; i<m; i++)
    {
        cin>>a>>b;
        conn[a].push_back(b);
        conn[b].push_back(a);
    }
    bool visited[n+1]; //visited node 1 to last
    for(int i=0; i<n+1; i++)
    {
        visited[i]=false;  //making each and every node false
    }
    queue<int> Q;  //creating a queue
    Q.push(start); //pushing the starting node in the queue
    visited[start]=true; //make the starting node only true
    int siz=0;
    int lev=0;
    while(!Q.empty())
    {
        cout<<"LEVEL:"<<lev<<endl;
        siz=Q.size();
        while(siz--)
        {
            int first=Q.front();
            Q.pop();
            cout<<first<<endl;
            for(int j=0; j<conn[first].size(); j++)
            {
                if(!visited[conn[first][j]])
                {
                visited[conn[first][j]]=true; //making true which have visited
                Q.push(conn[first][j]); //pushing the value in the queue
                }
            }

        }
        lev++; //level increasing in each iteration
    }
return 0;
}

//bfs implementation for undirected unweighted graph

#include<fstream>

#include<queue>

#include<vector>

#include<iostream>

using namespace std;

int main()

{

int n,m,start;

int a,b;

cin>>n>>m>>start;

vector<int> samp;

vector<vector<int> > conn(n+1,samp); //conn taking custom value in vector to make it sizeable

//loading adjacency matrix

for(int i=0; i<m; i++)

{

cin>>a>>b;

conn[a].push_back(b);

conn[b].push_back(a);

}

bool visited[n+1]; //visited node 1 to last

for(int i=0; i<n+1; i++)

{

visited[i]=false; //making each and every node false

}

queue<int> Q; //creating a queue

Q.push(start); //pushing the starting node in the queue

visited[start]=true; //make the starting node only true

int siz=0;

int lev=0;

while(!Q.empty())

{

cout<<"LEVEL:"<<lev<<endl;

siz=Q.size();

while(siz--)

{

int first=Q.front();

Q.pop();

cout<<first<<endl;

for(int j=0; j<conn[first].size(); j++)

{

if(!visited[conn[first][j]])

{

visited[conn[first][j]]=true; //making true which have visited

Q.push(conn[first][j]); //pushing the value in the queue

}

lev++; //level increasing in each iteration

}

return 0;

}

Input:

9 10 1 //here 1 is starting node that can be any value
1 2
1 3
3 4
3 5
1 6
4 6
4 9
9 8
1 7
7 3

9 10 1 //here 1 is starting node that can be any value

1 2

1 3

3 4

3 5

1 6

4 6

4 9

9 8

1 7

7 3

Output:

Another code tried to write from the pseudocode is:

#include<iostream>
#include<queue>
#include<bits/stdc++.h>
using namespace std;
//void BFS(int);
int WHITE=1,GRAY=2,BLACK=3,inf=31000,NIL=-1;
int num_e,num_v;
queue<int> Q;
int adj[20][20],color[20],d[20],p[20];
void initialization()
{
    int k,j;
    for(k=0; k<20; k++)
    {
        for(j=0; j<20; j++)
        {
            adj[k][j]=0;
        }
    }
}
void build_adj_matrix()
{
    int i,a,b;
    cin>>num_v;
    cin>>num_e;
    for(i=1; i<=num_e; i++)
    {
        cin>>a>>b;
        adj[a][b]=1;
        adj[b][a]=1;
    }
}
void BFS(int s)
{
    int i,u,v;
    for(i=1; i<=num_v; i++)
    {
        color[i]=WHITE;
        d[i]=inf;
        p[i]=NIL;
    }
    color[s]=GRAY;
    d[s]=0;
    p[s]=NIL;
    Q.push(s);
    while(!Q.empty())
    {
        int u=Q.pop();
        for(v=1; v<=num_v; v++)
        {
            if(adj[u][v]==1)
            {
                if(color[v]==WHITE)
                {
                    color[v]=GRAY;
                    d[v]=d[u]+1;
                    p[v]=u;
                    Q.push(v);
                }
            }
        }
        color[u]=BLACK;
    }
}
void distance_output()
{
    int i;
    cout<<"Shortest path from source vertex";
    for(i=1; i<=num_v; i++)
    {
        cout<<"to node "<<i<<"is "<<d[i];

    }
}
void path_print(int s,int v)
{
    if(v==s)
    {
        cout<<s<<endl;
    }
    else if(p[v]==NIL)
    {
        cout<<"No path from"<<s<<"to "<<v<<"exists";
    }
    else
    {
        path_print(s,p[v]);
        cout<<v<<endl;
    }
}
int main()
{

    int source,destination;
    initialization();
    build_adj_matrix();
    cin>>source;
    cin>>destination;
    BFS(source);
    distance_output();
    path_print(source,destination);
    return 0;
}

100

101

102

103

#include<iostream>

#include<queue>

#include<bits/stdc++.h>

using namespace std;

//void BFS(int);

int WHITE=1,GRAY=2,BLACK=3,inf=31000,NIL=-1;

int num_e,num_v;

queue<int> Q;

int adj[20][20],color[20],d[20],p[20];

void initialization()

{

int k,j;

for(k=0; k<20; k++)

{

for(j=0; j<20; j++)

{

adj[k][j]=0;

}

void build_adj_matrix()

{

int i,a,b;

cin>>num_v;

cin>>num_e;

for(i=1; i<=num_e; i++)

{

cin>>a>>b;

adj[a][b]=1;

adj[b][a]=1;

}

void BFS(int s)

{

int i,u,v;

for(i=1; i<=num_v; i++)

{

color[i]=WHITE;

d[i]=inf;

p[i]=NIL;

}

color[s]=GRAY;

d[s]=0;

p[s]=NIL;

Q.push(s);

while(!Q.empty())

{

int u=Q.pop();

for(v=1; v<=num_v; v++)

{

if(adj[u][v]==1)

{

if(color[v]==WHITE)

{

color[v]=GRAY;

d[v]=d[u]+1;

p[v]=u;

Q.push(v);

}

color[u]=BLACK;

}

void distance_output()

{

int i;

cout<<"Shortest path from source vertex";

for(i=1; i<=num_v; i++)

{

cout<<"to node "<<i<<"is "<<d[i];

}

void path_print(int s,int v)

{

if(v==s)

{

cout<<s<<endl;

}

else if(p[v]==NIL)

{

cout<<"No path from"<<s<<"to "<<v<<"exists";

}

else

{

path_print(s,p[v]);

cout<<v<<endl;

}

int main()

{

int source,destination;

initialization();

build_adj_matrix();

cin>>source;

cin>>destination;

BFS(source);

distance_output();

path_print(source,destination);

return 0;

}

reference from java code: http://www.programmingboss.com/2014/06/breadth-first-search-bfs-in-java.html

ppt slide: https://drive.google.com/file/d/0B0sCkwd_qKgJSzZyUWVYZU5GWlk/edit

Leave a comment

Posted in A ll Codes, Algorithm, BFS, C, C Refresh

Depth Firtst Search(DFS) Algorithm Explanation and Implementation in C++

Posted on December 31, 2015 | Leave a comment

Discovery Time and Finishing Time Code:

//dfs using adjacency list in directed graph
#include<iostream>
using namespace std;
int WHITE=1,GREY=2,BLACK=3,INF=310000,NIL=-1;
int num_v,num_e,time=0;
int adj[20][20],color[20],p[20],d[20],f[20];
void DFS_visit(int);
void initialization()
{
    int k,j;
    for(k=0; k<20; k++)
    {
        for(j=0; j<20; j++)
        {
            adj[k][j]=0;
        }
    }

}
void build_adj_matrix()
{
    int i,a,b;
    cout<<"Enter number of vertices: "<<endl;
    cin>>num_v;
    cout<<"Enter number of edges: "<<endl;
    cin>>num_e;
    cout<<"Enter edges: "<<endl;
    for(i=1; i<=num_e; i++)
    {
        cin>>a>>b;
        adj[a][b]=1;
    }
}
void dfs()
{
    int i,u;
    for(i=1; i<=num_v; i++)
    {
        color[i]=WHITE;
        p[i]=NIL;
    }
    for(u=1; u<=num_v; u++)
    {
        if(color[u]==WHITE)
        {
            DFS_visit(u);
        }
    }
}
void DFS_visit(int u)
{
    int i,v;
    color[u]=GREY;
    time=time+1;
    d[u]=time;
    for(v=1; v<=num_v; v++)
    {
        if(adj[u][v]==1)
        {
            if(color[v]==WHITE)
            {
                p[v]=u;
                DFS_visit(v);
            }
        }
    }
    color[u]=BLACK;
    time=time+1;
    f[u]=time;
}
void distance_output()
{
    int i;
    cout<<"Discovery time and finish time:\n";
    for(i=1; i<=num_v; i++)
    {
        cout<<"Node "<<i<<" is "<<d[i]<<"/"<<f[i]<<" \n";
    }
}
int main()
{
    initialization();
    build_adj_matrix();
    dfs();
    distance_output();
    return 0;
}

//dfs using adjacency list in directed graph

#include<iostream>

using namespace std;

int WHITE=1,GREY=2,BLACK=3,INF=310000,NIL=-1;

int num_v,num_e,time=0;

int adj[20][20],color[20],p[20],d[20],f[20];

void DFS_visit(int);

void initialization()

{

int k,j;

for(k=0; k<20; k++)

{

for(j=0; j<20; j++)

{

adj[k][j]=0;

}

void build_adj_matrix()

{

int i,a,b;

cout<<"Enter number of vertices: "<<endl;

cin>>num_v;

cout<<"Enter number of edges: "<<endl;

cin>>num_e;

cout<<"Enter edges: "<<endl;

for(i=1; i<=num_e; i++)

{

cin>>a>>b;

adj[a][b]=1;

}

void dfs()

{

int i,u;

for(i=1; i<=num_v; i++)

{

color[i]=WHITE;

p[i]=NIL;

}

for(u=1; u<=num_v; u++)

{

if(color[u]==WHITE)

{

DFS_visit(u);

}

void DFS_visit(int u)

{

int i,v;

color[u]=GREY;

time=time+1;

d[u]=time;

for(v=1; v<=num_v; v++)

{

if(adj[u][v]==1)

{

if(color[v]==WHITE)

{

p[v]=u;

DFS_visit(v);

}

color[u]=BLACK;

time=time+1;

f[u]=time;

}

void distance_output()

{

int i;

cout<<"Discovery time and finish time:\n";

for(i=1; i<=num_v; i++)

{

cout<<"Node "<<i<<" is "<<d[i]<<"/"<<f[i]<<" \n";

}

int main()

{

initialization();

build_adj_matrix();

dfs();

distance_output();

return 0;

}

input/output:

Enter number of vertices:
4
Enter number of edges:
4
Enter edges:
2 3
2 1
1 4
3 4
Discovery time and finish time:
Node 1 is 1/4
Node 2 is 5/8
Node 3 is 6/7
Node 4 is 2/3

Enter number of vertices:

Enter number of edges:

Enter edges:

2 3

2 1

1 4

3 4

Discovery time and finish time:

Node 1 is 1/4

Node 2 is 5/8

Node 3 is 6/7

Node 4 is 2/3

pseudo:

void DFS_visit(int u){
	int i,v;
	colour[u]=GREY;
	time=time+1;
	d[u]=time;
	for(v=1;v<=num_v;v++)
	{
		if(adj[u][v]==1){
			if(color[v]==WHITE){
				p[v]=u;
				DFS_visit(v);
			}
		}
	
	}
	color[u]=BLACK;
	time=time+1;
	f[u]=time;
}

void DFS_visit(int u){

int i,v;

colour[u]=GREY;

time=time+1;

d[u]=time;

for(v=1;v<=num_v;v++)

{

if(adj[u][v]==1){

if(color[v]==WHITE){

p[v]=u;

DFS_visit(v);

}

color[u]=BLACK;

time=time+1;

f[u]=time;

}

Pseudocode from shafayet vai’s blog:

procedure DFS(G, source):
  U ← source
  time  ← time+1
  d[u]  ← time
  color[u]  ← GREY
  for all edges from u to v in G.adjacentEdges(v) do        
    if color[v] = WHITE
     DFS(G,v)
    end if
  end for
  color[u] ← BLACK
  time ← time+1
  f[u] ← time
  return

procedure DFS(G, source):

U ← source

time ← time+1

d[u] ← time

color[u] ← GREY

for all edges from u to v in G.adjacentEdges(v) do

if color[v] = WHITE

DFS(G,v)

end if

end for

color[u] ← BLACK

time ← time+1

f[u] ← time

return

Reference:
http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/GraphAlgor/depthSearch.htm
http://www.dotnetlovers.com/Article/182/implementation-of-depth-first-searchdfs

Another code to find the order of the node:
References:
One of my classmates blog link: http://programminghelpbd.blogspot.com/2014/06/breadth-first-search-dfs-in-java.html
and this ppt : https://drive.google.com/file/d/0B0sCkwd_qKgJZEJzS1pWeXNmNUE/edit
CLRS website: http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/GraphAlgor/depthSearch.htm

Shafayet Ashraf: http://www.shafaetsplanet.com/planetcoding/?p=973

saurabhschool youtube link : https://www.youtube.com/watch?v=gCNsAKkUHPM

Youtube video of Mifta Sintaha:

and here is also a good implementation:
http://electrofriends.com/source-codes/software-programs/cpp-programs/cpp-data-structure/c-programs-for-the-implementation-of-depth-first-searchdfs-for-a-given-graph/comment-page-1/#comments

Java array basics: http://www.tutorialspoint.com/java/java_arrays.htm

Another code to find the order of vertices:

#include<iostream>
#include<conio.h>
#include<stdlib.h>
using namespace std;
int adj[10][10],i,j,k,n,stk[10],top,v,visit[10],visited[10];

main()
{
    int m;
    cout <<"enterno of vertices";
    cin >> n;
    cout <<"ente no of edges";
    cin >> m;
    cout <<"\nEDGES \n";
    for(k=1; k<=m; k++)
    {
        cin >>i>>j;
        adj[i][j]=1;
    }

    cout <<"enter initial vertex:";
    cin >>v;
    cout <<"ORDER OF VISITED VERTICES: ";
    cout << v <<" ";
    visited[v]=1;
    k=1;
    while(k<n)
    {
        for(j=n; j>=1; j--)
            if(adj[v][j]!=0 && visited[j]!=1 && visit[j]!=1)
            {
                visit[j]=1;
                stk[top]=j;
                top++;
            }
        v=stk[--top];
        cout<<v << " ";
        k++;
        visit[v]=0;
        visited[v]=1;
    }
}

#include<iostream>

#include<conio.h>

#include<stdlib.h>

using namespace std;

int adj[10][10],i,j,k,n,stk[10],top,v,visit[10],visited[10];

main()

{

int m;

cout <<"enterno of vertices";

cin >> n;

cout <<"ente no of edges";

cin >> m;

cout <<"\nEDGES \n";

for(k=1; k<=m; k++)

{

cin >>i>>j;

adj[i][j]=1;

}

cout <<"enter initial vertex:";

cin >>v;

cout <<"ORDER OF VISITED VERTICES: ";

cout << v <<" ";

visited[v]=1;

k=1;

while(k<n)

{

for(j=n; j>=1; j--)

if(adj[v][j]!=0 && visited[j]!=1 && visit[j]!=1)

{

visit[j]=1;

stk[top]=j;

top++;

}

v=stk[--top];

cout<<v << " ";

k++;

visit[v]=0;

visited[v]=1;

}

Leave a comment

Posted in Algorithm, DFS

Tagged C++, Depth Firtst Search(DFS) Algorithm Explanation and Implementation

Category Archives: Graph

Floyd Warshall Algorithm

Bellman Ford

Dijkstra

Topological Sort

Algorithm: BFS(Breadth First Search)

Depth Firtst Search(DFS) Algorithm Explanation and Implementation in C++

Caution and Tips:

Category

About Me & MyBlog

Recent Posts

Recent Comments

My Facebook

My Algorithmic Progress in OJ’s

My Github

My Linkedin

Count per Day

Archives

This site is powered by:

Bookmarks

My Coding Page

Top Posts & Pages

My Skills

My Poster/Presentations

My Videos

My Bookshelf

Quote From Life

Category Archives: Graph

Floyd Warshall Algorithm

Bellman Ford

Dijkstra

Topological Sort

Algorithm: BFS(Breadth First Search)

Depth Firtst Search(DFS) Algorithm Explanation and Implementation in C++

Caution and Tips:

Category

About Me & MyBlog

Recent Posts

Recent Comments

My Facebook

My Algorithmic Progress in OJ’s

My Github

My Linkedin

Tags

Count per Day

Archives

This site is powered by:

Bookmarks

My Coding Page

Top Posts & Pages

My Skills

My Poster/Presentations

My Videos

My Bookshelf

Quote From Life