Ever been troubled by segmentation faults .. now use gdb to take a closer inspection..

GDB stands for GNU Debugger which is a debugger for C and C++ .For any file you need to add -g to enable default debugging support.For enabling gdb just type gdb or gdb <filename> .If you did not mention the file earlier you can mention it by using the file command.
(gdb) file prog1.x
To run the program:
(gdb)run
If the program does have issues you will get information about where the program crashed i.e the line number and parameters to the function that caused the error.

The break command is used for setting the breakpoints in the program.For setting breakpoints in the file line pair use:
(gdb) break file.c:8
For breaking at a particular function use:
(gdb)break fib_func

To proceed to the next breakpoint use the continue statement:
(gdb)continue
To proceed one step at a time use the step statement:
(gdb)step

To print the value of the variables at any given time use the print command which prints the value of the variables and the print/x which gives the value of the variables mentioned in the program as hexadecimal.

Breakpoints stop the program at the points in the program ..whereas watchpoints watch over changes in the variables .
(gdb) watch i
whenever i is modified the program interrupts and prints out the old and the new values.Other useful commands are:
backtrace - produces a stack trace of the function calls that lead to a seg fault
finish - runs until the current function is finished
delete - deletes a specified breakpoint
info breakpoints - shows information about all declared breakpoints
                                                                                                                                                                                                                                                
Breakpoints are a tedious task of getting data always out of programs.To get specific
parts you can use conditional breakpoints like:
(gdb)break file1.c:6 if i >= ARRAYSIZE

So now you can try out various commands in your terminal and check out the gdb
manual for more details.

A Randomized Algorithm is one in which we use a randomizer or some kind of random number.Some decisions made in the algorithm depend on the output of the randomizer.Hence they have different runtime each time they are run even if the input is correct.
      Randomized algorithms can be divided into two categories:
Las Vegas Algorithms : These algorithms always give the correct output, however their runtime differ based on the output of the randomizer
Monte Carlo Algorithms: These algorithms give the correct answer for most of the cases however they may give incorrect answers for a small percent of values.

Primality testing using Miller-Rabin's Method: This algorithm makes use of Fermat theorem i.e. if n is prime than a^(n-1) %n=1 for any a<n.

Th2: The equation x^2%n=1 has exactly two solutions namely 1 and n-1
Th3: The equation x^2(mod n)=1 has roots other than 1 and n-1 then n is composite

The algorithm fails for some composite numbers (Carmichael numbers) for which every a that is less than and relatively prime to n will satisfy Fermats theorem.e.g 561 and 1105

Implementation:

int prime(int n,int alpha)
{
  int q=n-1;int i;
  int up=(int)alpha*log(n);
  int m,y,a,z,x;
  for(i=0;i<up;i++)
    {
      m=q;y=1;
      a=rand()%q+1;
      //choosing a random number in the range [1,n-1]
      z=a;
      //compute a^n-1 mod n
      while(m>0)
    {
      while(m%2==0)
        {
          x=z;
          z=(z*z)%n;
          if((z==1)&&(x!=1)&&(x!=q))
        return 0;
          m=(int)m/2;
        }
      m=m-1;y=(y*z)%n;
    }
      if(y!=1)
    return 0;
      //if a^n-1 mod n is not 1 n is not a prime
    }
  return 1;
}

#include<stdio.h>
#include<assert.h>
#include<conio.h>
/* maxVertices represents maximum number of vertices that can be present in the graph. */
/*graph is undirected and not weighted*/
#define maxVertices   100
void Dfs(int graph[][maxVertices],int *size,int presentVertex,int *visited)
{
     printf("Now visiting vertex %d\n",presentVertex);
     visited[presentVertex]=1;
     /* Iterate through all the vertices connected to the presentVertex and perform dfs on those
           vertices if they are not visited before */
     int iter;
     for(iter=0;iter<size[presentVertex];iter++)
     {
             if(!visited[graph[presentVertex][iter]])
             Dfs(graph,size,graph[presentVertex][iter],visited);
     }
     return;
}
/* Input Format: Graph is directed and unweighted. First two integers must be number of vertces and edges 
   which must be followed by pairs of vertices which has an edge between them. */
int main()
{
        int graph[maxVertices][maxVertices],size[maxVertices]={0},visited[maxVertices]={0};
        int vertices,edges,iter;
        /* vertices represent number of vertices and edges represent number of edges in the graph. */
        scanf("%d%d",&vertices,&edges);
        int vertex1,vertex2;
        for(iter=0;iter<edges;iter++)
        {
                scanf("%d%d",&vertex1,&vertex2);
                assert(vertex1>=0 && vertex1<vertices);
                assert(vertex2>=0 && vertex2<vertices);
                graph[vertex1][size[vertex1]++] = vertex2;
        }
        int presentVertex;
        for(presentVertex=0;presentVertex<vertices;presentVertex++)
        {
                if(!visited[presentVertex])
                {
                        Dfs(graph,size,presentVertex,visited);
                }
        }
        getche();
        return 0;

}     


--------------------------------------PYTHON IMPLEMENTATION---------------------------------------------

def dfs(graph,p_vertex,visited):
    print("Visiting vertex {0}".format(p_vertex))
    visited[p_vertex]=1
    #print(len(graph[p_vertex]))
    for itr in range(0,len(graph[p_vertex])):
        if(visited[graph[p_vertex][itr]]==0):
            #print("sent to visit vertex {0}".format(graph[p_vertex][itr]))
            dfs(graph,graph[p_vertex][itr],visited)
    return

vertices=int(input("Enter number of vertices::"))
edges=int(input("Enter the number of edges::"))
graph=[]
visited=[0]*vertices

#create the vertices
for i in range(0,vertices):
    v=[]
    graph.append(v)
#take input
for i in range(0,edges):
    v1,v2=input().split()
    v1,v2=int(v1),int(v2)
    assert(v1>=0 and v1<vertices)
    assert(v2>=0 and v2<vertices)
    graph[v1].append(v2)

print(graph)

for p_vertex in range(0,vertices):
    if(visited[p_vertex]==0):
        dfs(graph,p_vertex,visited)

# breadth first search in PYTHON 3.2 #
from queue import *

def bfs(graph,p_vertex,visited):
    q=Queue()
    q.put(p_vertex)
    visited[p_vertex]=1
    while q.qsize()>0:
        t=q.get()
        print("Visiting vertex {0}".format(t))
        #i.e if t is what we want return t
        for child in range(0,len(graph[p_vertex])):
            if(visited[graph[p_vertex][child]]==0):
                visited[graph[p_vertex][child]]=1
                q.put(graph[p_vertex][child])
    return

vertices=int(input("Enter number of vertices::"))
edges=int(input("Enter the number of edges::"))
graph=[]
visited=[0]*vertices

#create the vertices
for i in range(0,vertices):
    v=[]
    graph.append(v)
#take input
for i in range(0,edges):
    v1,v2=input().split()
    v1,v2=int(v1),int(v2)
    assert(v1>=0 and v1<vertices)
    assert(v2>=0 and v2<vertices)
    graph[v1].append(v2)
print(graph)

for p_vertex in range(0,vertices):
    if(visited[p_vertex]==0):
        bfs(graph,p_vertex,visited)


----------->For those interested in C implimentation might find this a little long then python but here it is-------------->


#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
/* maxVertices represents maximum number of vertices that can be present in the graph. */
#define maxVertices   100
typedef struct Queue
{
        int capacity;
        int size;
        int front;
        int rear;
        int *elements;
}Queue;
/* crateQueue function takes argument the maximum number of elements the Queue can hold, creates
   a Queue according to it and returns a pointer to the Queue. */
Queue * CreateQueue(int maxElements)
{
        /* Create a Queue */
        Queue *Q;
        Q = (Queue *)malloc(sizeof(Queue));
        /* Initialise its properties */
        Q->elements = (int *)malloc(sizeof(int)*maxElements);
        Q->size = 0;
        Q->capacity = maxElements;
        Q->front = 0;
        Q->rear = -1;
        /* Return the pointer */
        return Q;
}
void Dequeue(Queue *Q)
{
        /* If Queue size is zero then it is empty. So we cannot pop */
        if(Q->size==0)
        {
                printf("Queue is Empty\n");
                return;
        }
        /* Removing an element is equivalent to incrementing index of front by one */
        else
        {
                Q->size--;
                Q->front++;
                /* As we fill elements in circular fashion */
                if(Q->front==Q->capacity)
                {
                        Q->front=0;
                }
        }
        return;
}
int Front(Queue *Q)
{
        if(Q->size==0)
        {
                printf("Queue is Empty\n");
                exit(0);
        }
        /* Return the element which is at the front*/
        return Q->elements[Q->front];
}
void Enqueue(Queue *Q,int element)
{
        /* If the Queue is full, we cannot push an element into it as there is no space for it.*/
        if(Q->size == Q->capacity)
        {
                printf("Queue is Full\n");
        }
        else
        {
                Q->size++;
                Q->rear = Q->rear + 1;
                /* As we fill the queue in circular fashion */
                if(Q->rear == Q->capacity)
                {
                        Q->rear = 0;
                }
                /* Insert the element in its rear side */
                Q->elements[Q->rear] = element;
        }
        return;
}



void Bfs(int graph[][maxVertices], int *size, int presentVertex,int *visited)
{
        visited[presentVertex] = 1;
        /* Iterate through all the vertices connected to the presentVertex and perform bfs on those
           vertices if they are not visited before */
        Queue *Q = CreateQueue(maxVertices);
        Enqueue(Q,presentVertex);
        while(Q->size)
        {
                presentVertex = Front(Q);
                printf("Now visiting vertex %d\n",presentVertex);
                Dequeue(Q);
                int iter;
                for(iter=0;iter<size[presentVertex];iter++)
                {
                        if(!visited[graph[presentVertex][iter]])
                        {
                                visited[graph[presentVertex][iter]] = 1;
                                Enqueue(Q,graph[presentVertex][iter]);
                        }
                }
        }
        return;


}
/* Input Format: Graph is directed and unweighted. First two integers must be number of vertces and edges
   which must be followed by pairs of vertices which has an edge between them. */
int main()
{
        int graph[maxVertices][maxVertices],size[maxVertices]={0},visited[maxVertices]={0};
        int vertices,edges,iter;
        /* vertices represent number of vertices and edges represent number of edges in the graph. */
        scanf("%d%d",&vertices,&edges);
        int vertex1,vertex2;
        for(iter=0;iter<edges;iter++)
        {
                scanf("%d%d",&vertex1,&vertex2);
                assert(vertex1>=0 && vertex1<vertices);
                assert(vertex2>=0 && vertex2<vertices);
                graph[vertex1][size[vertex1]++] = vertex2;
        }
        int presentVertex;
        for(presentVertex=0;presentVertex<vertices;presentVertex++)
        {
                if(!visited[presentVertex])
                {
                        Bfs(graph,size,presentVertex,visited);
                }
        }
        return 0;
}

------------------------------------------------------->END<------------------------------------------------------------------

Here is another important graph algo for finding the minimum weighted spanning tree imlimented in C.Input is taken from adj matrix with non-conn terms having val in #define MAXVAL & the number of vert changed by changing #define MAXVAL...


/*KRUSKAL ALGORITHM IN C*/
#include<stdio.h>
#define VERT 4 //predefined number of vertices
#define MAXVAL 99
void kruskal(int a[][VERT],int n);
int gethead(int vert,int par[]);
void vertex_union(int v1,int v2,int par[]);

void vertex_union(int v1,int v2,int par[])
{
    if(v1>v2)
    par[v1]=v2;
    else
    par[v2]=v1;
}

int gethead(int vert,int par[])
{
    while(par[vert]!=vert)
    {
        vert=par[vert];
    }
    return vert;
}

void kruskal(int a[][VERT],int n)
{
    int nofedges,i,parent[VERT],min,j,k,u,v,path[VERT-1][2],sum;
    nofedges=k=sum=0;
    for(i=0;i<n;i++)
    parent[i]=i;//sets parent
    while(nofedges<n-1)
    {
        min=MAXVAL;
        for(i=0;i<n;i++)
        for(j=0;j<n;j++)
        if(a[i][j]<min)
        {
            min=a[i][j];
            u=i;
            v=j;
        }//gets the min for each turn
        if(min!=MAXVAL)
        {
            i=gethead(u,parent);
            j=gethead(v,parent);
            /*printf("==>%d %d %d %d\n",i,j,u,v);
            int ii;
            for(ii=0;ii<VERT;ii++)
            printf("%d ",parent[ii]);
            printf("\n");*/
            if(i!=j)
            {
                //printf("-->adding vertex %d %d",u,v);
                path[k][0]=u;
                path[k][1]=v;
                k++;
                sum+=min;
                vertex_union(i,j,parent);
                nofedges+=1;
            }
            a[u][v]=a[v][u]=999;
        }
    }
    if(nofedges!=n-1)
    printf("Invalid Spanning Tree");
    else
    {
        printf("Minimum cost=%d\n",sum);
        printf("The edges included are ::\n");
        for(i=0;i<n-1;i++)
        printf("%d %d \n",path[i][0],path[i][1]);
    }
}

int main()
{
    int cost[VERT][VERT],i,j;
    for(i=0;i<VERT;i++)
    for(j=0;j<VERT;j++)
    scanf("%d",&cost[i][j]);
    //adjacency matrix entered
    kruskal(cost,VERT);

}

Hope you enjoyed this..

 Complete implementation only without the delete method ... If anyone wants it i will post it later in the comments :

import java.io.*;

class Node

{

int data;

Node leftchild;

Node rightchild;

Node parent;

public Node(int d)

{

    data=d;

    leftchild=null;

    rightchild=null;

}

public int get_data()

{

    return data;

}

public Node get_leftchild()

{

    return leftchild;

}

public Node get_rightchild()

{

    return rightchild;

}

public void set_data(int d)

{

    data=d;

}

public void set_leftchild(Node n)

{

    leftchild=n;

}

public void set_rightchild(Node n)

{

    rightchild=n;

}

public void set_parent(Node n)

{

    parent=n;

}

public Node get_parent()

{

    return parent;

}

}



//end of the node class



//start

class Avl

{

Node root;

public Avl()

{

    root=null;

}



public int max(int a,int b)

{

    if(a>b)

    return a;

    else

    return b;

}



public int get_height(Node n)

{

    if(n==null)

    return 0;

    else

    return max(get_height(n.get_leftchild()),get_height(n.get_rightchild()))+1;

}



public void left_left_rot(Node k2)

{

    Node k1=k2.get_leftchild();

    Node B=k1.get_rightchild();

    Node gp=k2.get_parent();

    if(gp!=null)

    {

        if(gp.get_rightchild()==k2)

        {

            gp.set_rightchild(k1);

            k1.set_parent(gp);

        }

        else

        {

            gp.set_leftchild(k1);

            k1.set_parent(gp);

        }

    }

    else

    {

    k1.set_parent(null);

    }

    k1.set_rightchild(k2);

    if(k1!=null)

    k2.set_parent(k1);

    k2.set_leftchild(B);

    if(B!=null)

    B.set_parent(k2);

}



public void right_right_rot(Node x)

{

    Node y=x.get_rightchild();

    Node B=y.get_leftchild();

    Node gp=x.get_parent();

    if(gp.get_rightchild()==x)

    {

        gp.set_rightchild(y);

        y.set_parent(gp);

        }

    else

    {

        gp.set_leftchild(y);

        y.set_parent(gp);

    }

    y.set_leftchild(x);

    x.set_parent(y);

    x.set_rightchild(B);

    if(B!=null)

    B.set_parent(x);

}



public void left_right_rot(Node k3)

{

    Node k1=k3.get_leftchild();

    Node k2=k1.get_rightchild();

    Node B=k2.get_leftchild();

    Node C=k2.get_rightchild();

    Node par=k3.get_parent();

    if(par.get_leftchild()==k3)

    par.set_leftchild(k2);

    else

    par.set_rightchild(k2);

    if(k2!=null)

    k2.set_parent(par);

    k2.set_leftchild(k1);

    if(k1!=null)

    k1.set_parent(k2);

    k2.set_rightchild(k3);

    if(k3!=null)

    k3.set_parent(k2);

    k1.set_rightchild(B);

    k3.set_leftchild(C);

    if(B!=null)

    B.set_parent(k1);

    if(C!=null)

    C.set_parent(k3);

}



public void right_left_rot(Node k1)

{

    Node k3=k1.get_rightchild();

    Node k2=k3.get_leftchild();

    Node C=k2.get_rightchild();

    Node B=k2.get_leftchild();

    Node par=k1.get_parent();

    if(par.get_leftchild()==k1)

    par.set_leftchild(k2);

    else

    par.set_rightchild(k2);

    if(k2!=null)

    k2.set_parent(par);

    k2.set_rightchild(k3);

    k2.set_leftchild(k1);

    if(k3!=null)

    k3.set_parent(k2);

    if(k1!=null)

    k1.set_parent(k2);

    k1.set_rightchild(B);

    k3.set_leftchild(C);

    if(B!=null)

    B.set_parent(k1);

    if(C!=null)

    C.set_parent(k3);

}

    



public int balance_factor(Node n)

{

    Node n1=n.get_rightchild();

    Node n2=n.get_leftchild();

    int h1,h2;

    h1=get_height(n1);

    h2=get_height(n2);

    return (h2-h1);

}

public Node returnUnbalanced(Node n)

{

    Node unbal=null;

    int checkflag=1;

    if(get_height(n.get_parent())==1)

    return unbal;

    int bf;

    while(n.get_parent()!=null)

    {

        n=n.get_parent();

        bf=balance_factor(n);

        if(checkflag==1)

        if((bf==2)||(bf==-2))

        {

            unbal=n;

            checkflag=0;

        }

    }

    return unbal;

}





    

public void insert(Node n,Node bs)

{

    if(bs==null)

    {

        root=n;

    }

    else

    {

        if(bs.get_data()>n.get_data())

        {

            if(bs.get_leftchild()==null)

            {

                bs.set_leftchild(n);

                n.set_parent(bs);

                Node unbal=returnUnbalanced(n);

                if(unbal!=null)

                {//balance it

                    int bf=balance_factor(unbal);

                    System.out.println("node ::"+unbal.get_data());

                    if(bf==2)

                    {

                        int bf2=balance_factor(unbal.get_leftchild());

                        if(bf2==1)

                        left_left_rot(unbal);

                        if(bf2==-1)

                        left_right_rot(unbal);

                    }

                    if(bf==-2)

                    {

                        int bf2=balance_factor(unbal.get_rightchild());

                        if(bf2==1)

                        right_left_rot(unbal);

                        if(bf2==-1)

                        right_right_rot(unbal);

                    }

                }

            }

            else

            insert(n,bs.get_leftchild());

        }

        else

        {

            if(bs.get_rightchild()==null)

            {

                bs.set_rightchild(n);

                n.set_parent(bs);

                Node unbal=returnUnbalanced(n);

                if(unbal!=null)

                {//perform the req bal op

                    int bf=balance_factor(unbal);

                    System.out.println("node::"+unbal.get_data());

                    if(bf==2)

                    {

                        int bf2=balance_factor(unbal.get_leftchild());

                        if(bf2==1)

                        left_left_rot(unbal);

                        if(bf2==-1)

                        left_right_rot(unbal);

                    }

                    if(bf==-2)

                    {

                        int bf2=balance_factor(unbal.get_rightchild());

                        if(bf2==1)

                        right_left_rot(unbal);

                        if(bf2==-1)

                        right_right_rot(unbal);

                    }

                }

            }

            else

            insert(n,bs.get_rightchild());

        }

    }

}



public void search(int n,Node bs)

{

    if(bs==null)

    System.out.println("not present in tree");

    else

    {

        if(bs.get_data()==n)

        System.out.println("Node is present in Tree");

        else if(bs.get_data()>n)

             search(n,bs.get_leftchild());

             else

             search(n,bs.get_rightchild());

    }

}



public Node findmin(Node bs)

{

    if(bs!=null)

        while(bs.get_leftchild()!=null)

        bs=bs.get_leftchild();

    return bs;

}



public Node findmax(Node bs)

{

    if(bs!=null)

        while(bs.get_rightchild()!=null)

        bs=bs.get_rightchild();

    return bs;

}



public void del(int n,Node bs)

{

    if(bs==null)

    System.out.println("node not found in tree");

    else

    {

        if(bs.get_data()==n)

        {

        //do the three cases

            //case 1.Node has no children;

            if((bs.get_leftchild()==null)&&(bs.get_rightchild()==null))

            {

                Node par=bs.get_parent();

                if(par.get_rightchild()==bs)

                par.set_rightchild(null);

                else

                par.set_leftchild(null);

            }

            //case 2.if Node has 1 child

            else

            {

                if((bs.get_leftchild()==null)||(bs.get_rightchild()==null))

                {

                    //System.out.println("here");

                    Node par=bs.get_parent();

                    Node child;

                    if(bs.get_leftchild()==null)

                    child=bs.get_rightchild();

                    else

                    child=bs.get_leftchild();

                    if(par.get_leftchild()==bs)

                    par.set_leftchild(child);

                    else

                    par.set_rightchild(child);

                }

                else //Node has 2 children

                {

                    Node min_r=findmin(bs.get_rightchild());

                    int tset=min_r.get_data();

                    //min would be that node itself or left leaf

                    Node par=min_r.get_parent();

                    if(par==bs)

                    {

                        bs.set_rightchild(min_r.get_rightchild());

                        bs.set_data(tset);

                    }

                    else

                    {

                        par.set_leftchild(null);

                        bs.set_data(tset);

                    }

                    

                }

            }

        }

        else if(bs.get_data()>n)

            del(n,bs.get_leftchild());

             else

            del(n,bs.get_rightchild());

    }

}



public void preorder(Node bs)

{

    if(bs==null)

    return;

    else

    {

        System.out.print(bs.get_data()+" ");

        preorder(bs.get_leftchild());

        preorder(bs.get_rightchild());

    }

}



public void postorder(Node bs)

{

    if(bs==null)

    return;

    else

    {

        postorder(bs.get_leftchild());

        postorder(bs.get_rightchild());

        System.out.print(bs.get_data()+" ");

    }

}



public void inorder(Node bs)

{

    if(bs==null)

    return;

    else

    {

        inorder(bs.get_leftchild());

        System.out.print(bs.get_data()+" ");

        inorder(bs.get_rightchild());

    }

}

}



class check

{

public static void main(String[] args)throws IOException

{

    FileReader fr=new FileReader("input.txt");

    BufferedReader br=new BufferedReader(fr);

    InputStreamReader isr=new InputStreamReader(System.in);

    BufferedReader br1=new BufferedReader(isr);

    String line=br.readLine();

    String[] numS=line.split(" ");

    int[] numbers=new int[numS.length];

    //create the bst

    Avl tree=new Avl();

    //input the elements

    for(int i=0;i<numS.length;i++)

    {

        numbers[i]=Integer.parseInt(numS[i]);

        Node n=new Node(numbers[i]);

        tree.insert(n,tree.root);

    }

    //print the preorder

    System.out.println("preorder traversal ::");

    tree.preorder(tree.root);

    System.out.println("\nPostorder traversal::");

    tree.postorder(tree.root);

    System.out.println("\ninorder traversal ::");

    tree.inorder(tree.root);

    //options

    Node nn;

    int d,s;

    while(true)

    {

    System.out.println("\n1.tree height\n2.Search(int)\n3.findmin()\n4.findmax()\n5.preorder()\n6.postorder()\n7.inorder()\n8.exit\n");

    int input=Integer.parseInt(br1.readLine());

    switch(input)

    {

        /*case 1: d=Integer.parseInt(br1.readLine());

            tree.del(d,tree.root);

            break;*/

        case 2: s=Integer.parseInt(br1.readLine());

            tree.search(s,tree.root);

            break;

        case 3: nn=tree.findmin(tree.root);

            System.out.println(nn.get_data());

            break;

        case 4: nn=tree.findmax(tree.root);

            System.out.println(nn.get_data());

            break;

        case 5:tree.preorder(tree.root);

            System.out.println();

            break;

        case 6:tree.postorder(tree.root);

            System.out.println();

            break;

        case 7:tree.inorder(tree.root);

            System.out.println();

            break;

        case 1:System.out.println(tree.get_height(tree.root));

            break;

        case 8:System.exit(1000);

            break;

        default:System.out.println("Not an option");

            break;

    }

    }

}

}

Here's a graph algorithm implementation of Dijkstra's Algorithm in C .. input preferences are mentioned in comments in the program....

###########################################################################
/*Dijkrtas algorithm in C*/
#define N 6 //the number of vertices
#include<stdio.h>
#define INFINITY 999
#define TRUE 1
#define FALSE 0

int allvisited(int visits[])//checks if all nodes are visited or not
{
    int i,flag=1;
    for(i=0;i<N;i++)
    {
        if(visits[i]!=1)
        flag=0;
    }
    return flag;
}

int dijkstra(int graph[][N],int target,int source)
{
    int visited[N],dist[N];
    //source -1 in actual matrix ..check row for neighbours
    //init
    int i;
    for(i=0;i<N;i++)
    {
        dist[i]=INFINITY;
        visited[i]=-1;
    }
    int start=source;
    while(!allvisited(visited))
    {
        //printf("--->start=%d\n",start);
        visited[start]=1;
        if(dist[start]==INFINITY)
        {
            dist[start]=0;
        }
        for(i=0;i<N;i++)
        {
            if(graph[start][i]!=INFINITY)//this is a neighbour of start
            {
                int d=dist[start]+graph[start][i];
                if(d<dist[i])
                dist[i]=d;
            }
        }
        //checking
        /*for(i=0;i<N;i++)
        printf("%d ",dist[i]);
        printf("\n");*/
        //get the next node i.e. will be the minimum of tentative dist and unvisited
        int min=INFINITY;
        int pos=INFINITY;
        for(i=0;i<N;i++)
        {
            if(visited[i]!=1)
            {
                if(dist[i]<min)
                {
                    min=dist[i];
                    pos=i;
                }
            }
        }
        //if pos==NULL then over
        if(pos==INFINITY)
        break;
        else
        start=pos;
        //printf("continue..\n");
    }
    return dist[target];
}

int main()
{
    int graph[N][N];
    int i,j;
    printf("Enter the graph::\n");
    for(i=0;i<N;i++)
    for(j=0;j<N;j++)
    scanf("%d",&graph[i][j]);
    //taken input must be symmetric and for i=j should be 0 and for not connected should be infinity as defined
    int src,tar;
    printf("Enter the source and target::");
    scanf("%d %d",&src,&tar);
    int dis=dijkstra(graph,tar-1,src-1);
    printf("min dist=%d",dis);
    return 0;
}
##################################################################################

If anyone wants the python or Java version please mention it in the comments and i will post it..