Saturday, 20 April 2013

client-server socket.




AIM:
                  Program for client-server socket.

THEORY:
            A socket is one endpoint of a two-way communication link between two programs running on the network. A socket is bound to a port number so that the TCP layer can identify the application that data is destined to be sent.Normally, a server runs on a specific computer and has a socket that is bound to a specific port number. The server just waits, listening to the socket for a client to make a connection request.
            On the client-side: The client knows the hostname of the machine on which the server is running and the port number on which the server is listening. To make a connection request, the client tries to rendezvous with the server on the server's machine and port. The client also needs to identify itself to the server so it binds to a local port number that it will use during this connection. This is usually assigned by the system.
A client's connection request
            If everything goes well, the server accepts the connection. Upon acceptance, the server gets a new socket bound to the same local port and also has its remote endpoint set to the address and port of the client. It needs a new socket so that it can continue to listen to the original socket for connection requests while tending to the needs of the connected client.
The connection is made
            On the client side, if the connection is accepted, a socket is successfully created and the client can use the socket to communicate with the server.The client and server can now communicate by writing to or reading from their sockets.Socket classes are used to represent the connection between a client program and a server program. The java.net package provides two classes--Socket and ServerSocket--that implement the client side of the connection and the server side of the connection, respectively.
.
Running the Programs
            You must start the server program first. To do this, run the server program using the Java interpreter, just as you would any other Java application. Remember to run the server on the machine that the client program specifies when it creates the socket.
            Next, run the client program. Note that you can run the client on any machine on your network; it does not have to run on the same machine as the server.
            If you are too quick, you might start the client before the server has a chance to initialize itself and begin listening on the port. If this happens, you will see a stack trace from the client. If this happens, just restart the client.

CONCLUSION :
            Sockets are the means by which computers on a network communicate











































PROGRAM:

Client Server Socket

//SERVER:
import java.io.*;
import java.net.*;
public class Server
{
            public Server()
            {}
            public static void main(String args[])
            {
                        try
                        {
                                    String num1 = null;
                                    ServerSocket server = new ServerSocket(8080);
                                    Socket s= server.accept();
            BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
                                    PrintWriter out = new PrintWriter(s.getOutputStream(),true);
                                    num1 = in.readLine();
                                    System.out.println("The requested integer number is: "+ num1);
                                    int i=Integer.parseInt(num1);
                                    out.println(Integer.toHexString(0x10000|i).substring(1).toUpperCase());
                                    int binry[]= new int[8];
                                    int octal[] = new int[4];
                                    binaryconversion(binry,i);
                                    octalconv(octal,i);
                                    System.out.println();
                                    num1=Integer.toString(binry[0]);
                                    for(int p =1; p<8;p++)
                                    {
                                                num1=num1 + Integer.toString(binry[p]);
                                    }
                                    //binary number
                                    out.println(num1);
           
                                    num1=Integer.toString(octal[0]);
                                    for(int p =1; p<4;p++)
                                    {
                                                num1=num1+Integer.toString(octal[p]);
                                    }
                                    //octal number
                                    out.println(num1);
                        }
                        catch(IOException a)
                        {
                                    System.out.println("Error in input");
                        }
            }

            public static void binaryconversion(int binry[], int i)
            {
                        int k;
                        for(k=0;k<8;k++)
                                    binry[k]=0;
                        k=7;

                        for(int a=i;a>0;)
                        {
                                    binry[k]=a%2;
                                    a=a/2;
                                    k--;
                        }
            }
            public static void octalconv(int octal[], int i)
            {
                        int k;
                        for(k=0;k<4;k++)
                                    octal[k]=0;
                        k=3;

                        for(int a=i;a>0;)
                        {
                                    octal[k]=a%8;
                                    a=a/8;
                                    k--;
                        }
            }
}

OUTPUT
The requested integer number is: 42
                                            


























                                                                Client Server Socket

//CLIENT:
import java.io.*;
import java.net.*;
public class client
{
public client()
{}
public static void main(String args[])throws IOException
{
String num1 = null;
Socket s = new Socket("localhost",8080);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the number for conversion : ");
num1 = br.readLine();
BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
out.println(num1);
num1 = in.readLine();
System.out.println("The HEX number is:" + num1);

num1 = in.readLine();
System.out.println("The binary number is:" + num1);

num1 = in.readLine();
System.out.println("The Octal number is:" + num1);
}
}

OUTPUT:
Enter the number for conversion :
42
The HEX number is:002A
The binary number is:00101010
The Octal number is:0052


Objective Questions:
1.Java uses ______ class representing a server and ______ class representing the client that uses TCP protocol.
2. ______  is used to wait for accepting client connection requests.
3. In order to create a client socket connecting to a particular server, the IP address must be given to the client socket, otherwise, it cannot connect to the server: True or False.
4. Sockets provide an interface for programming networks at the transport layer: True or False.
5. Java TCP Socket uses the InputStream/OutputStream to read/write data to the network channel:
True or False.
6. Call Socket.close() method will close the TCP server that socket connects to: True or False.
7. The socket instance does not need to be explicitly closed to release all the resources it occupies, as the Java Garbage Collection mechanism will do it automatically: True or False
8. The following line of code
  Socket socket = new Socket(“localhost,” 1254);
  will create a TCP server at localhost port 1254: True or False.

Error detection & correction.



AIM:
Program for Error detection & correction.

THEORY:
Cyclic Redundancy Check
The cyclic redundancy check, or CRC, is a technique for detecting errors in digital data, but not for making corrections when errors are detected. It is used primarily in data transmission. In the CRC method, a certain number of check bits, often called a checksum, are appended to the message being transmitted. The receiver can determine whether or not the check bits agree with the data, to ascertain with a certain degree of probability whether or not an error occurred in transmission. If an error occurred, the receiver sends a “negative acknowledgement” (NAK) back to the sender, requesting that the message be retransmitted.
The technique is also sometimes applied to data storage devices, such as a disk drive. In this situation each block on the disk would have check bits, and the hardware might automatically initiate a reread of the block when an error is detected, or it might report the error to software. The material that follows speaks in terms of a “sender” and a “receiver” of a “message,” but it should be understood that it applies to storage writing and reading as well.
Take a binary message and convert it to a polynomial then divide it by another predefined polynomial called the key. The remainder from this division is the CRC. Now transmit both the message and the CRC. The recipient of the transmission does the same operation (divides the message by the same key) and compares his CRC with yours. If they differ, the message must have been mangled. If, on the other hand, they are equal, the odds are pretty good that the message went through uncorrupted. Most localized corruptions (burst of errors) will be caught using this scheme.
Not all keys are equally good. The longer the key, the better error checking. On the other hand, the calculations with long keys can get pretty involved. Ethernet packets use a 32-bit CRC corresponding to degree-31 remainder (remember, you need d + 1 coefficients for a degree-d polynomial). Since the degree of the remainder is always less than the degree of the divisor, the Ethernet key must be a polynomial of degree 32. A polynomial of degree 32 has 33 coefficients requiring a 33-bit number to store it. However, since we know that the highest coefficient (in front of x32) is 1, we don't have to store it. The key used by the Ethernet is 0x04c11db7. It corresponds to the polynomial:
x32 + x26 + ... + x2 + x + 1
There is one more trick used in packaging CRCs. First calculate the CRC for a message to which you have appended 32 zero bits. Suppose that the message had N bits, thus corresponding to degree N-1 polynomial. After appending 32 bits, it will correspond to a degree N + 31 polynomial. The top-level bit that was multiplying xN-1 will be now multiplying xN+31 and so on. In all, this operation is equivalent to multiplying the message polynomial by x32. If we denote the original message polynomial by M (x), the key polynomial by K (x) and the CRC by R (x) (remainder) we have:
M * x32 = Q (x) * K (x) + R (x)
Now add the CRC to the augmented message and send it away. When the recipient calculates the CRC for this sum, and there was no transmission error, he will get zero. That's because:
M * x32 + R (x) = Q (x) * K (x) (no remainder!)
You might think I made a sign mistake--it should be -R (x) on the left. Remember, however, that in arithmetic modulo 2 addition and subtraction are the same!

Hamming code
In telecommunication, Hamming codes are a family oflinear error-correcting codes that generalise theHamming(7,4)-code invented by Richard Hamming in 1950. Hamming codes can detect up to two and correct up to one bit errors. By contrast, the simple parity code cannot correct errors, and can detect only an odd number of errors. Hamming codes are special in that they are perfect codes, that is, they achieve the highest possible rate for codes with their block length and minimum distance 3.[1]
In mathematical terms, Hamming codes are a class of binary linear codes. For each integer   there is a code with block length n = 2r − 1 and message length k = 2r − r − 1. Hence the rate of Hamming codes is R = k / n = 1 − r / (2r − 1), which is highest possible for codes with distance 3 and block length 2r − 1. The parity-check matrix of a Hamming code is constructed by listing all columns of length r that are pairwise linearly independent.
Because of the simplicity of Hamming codes, they are widely used in computer memory (RAM). In this context, one often uses an extended Hamming code with one extra parity bit. Extended Hamming codes achieve a distance of 4, which allows the decoder to distinguish between the situation in which at most one bit error occurred and the situation in which two bit errors occurred. In this sense, extended Hamming codes are single-error correcting and double-error detecting, and often referred to as SECDED.

General algorithm
The following general algorithm generates a single-error correcting (SEC) code for any number of bits.
1. Number the bits starting from 1: bit 1, 2, 3, 4, 5, etc.
2. Write the bit numbers in binary. 1, 10, 11, 100, 101, etc.
3. All bit positions that are powers of two (have only one 1 bit in the binary form of their position) are parity bits.
4. All other bit positions, with two or more 1 bits in the binary form of their position, are data bits.
5. Each data bit is included in a unique set of 2 or more parity bits, as determined by the binary form of its bit position.
1. Parity bit 1 covers all bit positions which have the least significant bit set: bit 1 (the parity bit itself), 3, 5, 7, 9, etc.
2. Parity bit 2 covers all bit positions which have the second least significant bit set: bit 2 (the parity bit itself), 3, 6, 7, 10, 11, etc.
3. Parity bit 4 covers all bit positions which have the third least significant bit set: bits 4–7, 12–15, 20–23, etc.
4. Parity bit 8 covers all bit positions which have the fourth least significant bit set: bits 8–15, 24–31, 40–47, etc.
5. In general each parity bit covers all bits where the binary AND of the parity position and the bit position is non-zero.
CONCLUSION :
CRC, is a technique for detecting errors in digital data, but not for making corrections when errors are detected.
Hamming codes can detect up to two and correct up to one bit errors.






PROGRAM:
Cyclic Redundancy Check

import java.util.*;
class CRC2
{
public static void main(String S[])
{
Scanner K=new Scanner(System.in);
int m,n,T[],G[],i,j;
System.out.println("Enter length of message and GP");
m=K.nextInt();
n=K.nextInt();
if(n>m)
System.out.println("Length of GP shud be > than message");
else
{
T=new int[m+n-1];
System.out.println("Enter the message ");
for(i=0;i<m;i++)
T[i]=K.nextInt();
System.out.println();
for(i=m;i<m+n-1;i++)
T[i]=0;
System.out.println("Enter the G(P)");
G=new int[n];
for(i=0;i<n;i++)
G[i]=K.nextInt();
System.out.println("\n");

RM A=new RM();
int R[]=A.Remain(T,G,m,n); /*R is Remainder Array*/
for(i=0;i<n;i++)
System.out.println(R[i]);
System.out.println();
for(i=m,j=1;i<m+n-1;i++)
T[i]=R[j++];
R=A.Remain(T,G,m,n);

boolean f=true;
for(i=0;i<n;i++)
{
System.out.println(R[i]);
 if(R[i]==1) f=false;
}
if(f)
System.out.println("No Error is found");
else
System.out.println("Error is found");
}/*end else*/
}/*end main*/
}/*end class*/
class RM
{
int[] Remain(int T1[],int GP[],int m1,int n1)
{
int TP[]=new int[n1];
int j,i;
j=n1;
for(i=0;i<n1;i++)
TP[i]=T1[i];

while(j<m1+n1-1)
{
for(i=0;i<n1;i++)
if(TP[i]==GP[i])
TP[i]=0;
else TP[i]=1;
while(TP[0]!=1&&j<m1+n1-1)
{
for(i=0;i<(n1-1);i++)
TP[i]=TP[i+1];
TP[i]=T1[j];
j++;
}
}
return TP;
}
}




























Ouput:



























Program For Hamming Code

import java.util.*;
class Hamming
{
public static void main(String S[])
{
Scanner K=new Scanner(System.in);
int H[],P[],count,i,j,k,l,n,m;
P=new int[30];
System.out.println(" Enter Length of message");
n=K.nextInt();
H=new int[n+1];
System.out.println("Enter the message");
for(i=1;i<=n;i++)
H[i]=K.nextInt();
k=0;j=1;
for(i=1;i<=n;i++)
{
if(j==Math.pow(2,k))
{ P[j]=5;j++; k++;i--; }
else
{ P[j]=H[i];  j=j+1;  }
}
/*Filling the Parity Bits*/
k=0;count=0;
for(i=1;i<j;i++)
{
count=0;
if(i==Math.pow(2,k))
{
k++;
l=i;
while(l<j)
{
m=0;    /* 'm' is counter variable*/
while(m<i)
{
if(P[l]==1)
count++; m++; l++;
}
l=l+m;
}
if(count%2==0)
P[i]=0;
else
P[i]=1;
}
}
System.out.println("\n");
for(i=1;i<j;i++)
System.out.println(P[i]);
}
}

Output:



Bellman ford algorithm.



Aim:
Implementation of Bellman ford algorithm.

Theory:
Bellman-Ford algorithm solves the single-source shortest-path problem in the general case in which edges of a given digraph can have negative weight as long as G contains no negative cycles.
This algorithm, like Dijkstra's algorithm uses the notion of edge relaxation but does not use with greedy method. Again, it uses d[u] as an upper bound on the distance d[u, v] from u to v.
The algorithm progressively decreases an estimate d[v] on the weight of the shortest path from the source vertex s to each vertex v in V until it achieve the actual shortest-path. The algorithm returns Boolean TRUE if the given digraph contains no negative cycles that are reachable from source vertex s otherwise it returns Boolean FALSE.
BELLMAN-FORD (G, w, s)
  1. INITIALIZE-SINGLE-SOURCE (G, s)
  2. for each vertex i = 1 to V[G] - 1 do
  3.     for each edge (u, v) in E[G] do
  4.         RELAX (u, v, w)
  5. For each edge (u, v) in E[G] do
  6.     if d[u] + w(u, v) < d[v] then
  7.         return FALSE
  8. return TRUE

Analysis

  • The initialization in line 1 takes (v) time
  • For loop of lines 2-4 takes O(E) time and For-loop of line 5-7 takes O(E) time.
Asymptotic complexity:
• Average case (random data): O(|V ||E|)
• Worst case: O(|V ||E|)




Conclusion:
Thus, the Bellman-Ford algorithm runs in O(E) time.














Program:
Bellman.java
import java.io.*;
import java.util.*;
import java.io.DataInputStream;
class Edge
{
int source;
int dest;
int weight;
}
class Bellman
{
public static void BellmanFord(Edge edges[], int edgecount, int nodecount, int source)
{
int infinity=50000;
int i, j;
int distance[]=new int[nodecount];
for(i=0; i<nodecount; i++)
distance[i]=infinity;
distance[source]=0;
for(i=0; i<nodecount; i++)
{
boolean somethingchanged=false;
for(j=0; j<edgecount; j++)
{
if(distance[edges[j].source]!=infinity)
{
int new_distance=distance[edges[j].source]+edges[j].weight;
if(new_distance<distance[edges[j].dest])
{
distance[edges[j].dest]=new_distance;
somethingchanged=true;
}
}
}
if(!somethingchanged)
break;
}
for(i=0; i<edgecount; ++i)
{
if(distance[edges[i].dest]>distance[edges[i].source]+edges[i].weight)
System.out.println("Negative edge weight cycles detected!!!");
}
for(i=0; i<nodecount; ++i)
System.out.println("The shortest distance between nodes "+source+" & "+i+" is "+distance[i]);
}
public static void main(String args[])
{
Scanner in=new Scanner(System.in);
Edge edges[]=new Edge[10];
for( int i=0; i<10; i++)
{
edges[i]=new Edge();
System.out.print("Enter source number ["+i+"] : ");
edges[i].source=in.nextInt();
System.out.print("Enter destination number ["+i+"] : ");
edges[i].dest=in.nextInt();
System.out.print("Enter weight number ["+i+"] : ");
edges[i].weight=in.nextInt();
System.out.println();
}
BellmanFord(edges, 10, 5, 4);
}
}

OUTPUT:

C:\jdk1.6.0_18\bin>javac Bellman.java
C:\jdk1.6.0_18\bin>java Bellman
Enter source number [0] : 0
Enter destination number [0] : 1
Enter weight number [0] : 10

Enter source number [1] : 1
Enter destination number [1] : 2
Enter weight number [1] : 25

Enter source number [2] : 2
Enter destination number [2] : 3
Enter weight number [2] : 35

Enter source number [3] : 3
Enter destination number [3] : 0
Enter weight number [3] : 30

Enter source number [4] : 0
Enter destination number [4] : 2
Enter weight number [4] : 20

Enter source number [5] : 3
Enter destination number [5] : 1
Enter weight number [5] : 31

Enter source number [6] : 4
Enter destination number [6] : 3
Enter weight number [6] : 32


Enter source number [7] : 4
Enter destination number [7] : 2
Enter weight number [7] : 21

Enter source number [8] : 4
Enter destination number [8] : 0
Enter weight number [8] : 33

Enter source number [9] : 4
Enter destination number [9] : 1
Enter weight number [9] : 34

The shortest distance between nodes 4 & 0 is 33
The shortest distance between nodes 4 & 1 is 34
The shortest distance between nodes 4 & 2 is 21
The shortest distance between nodes 4 & 3 is 32
The shortest distance between nodes 4 & 4 is 0


Dijikshtras algorithm.



Aim:
Program for finding shortest path using Dijikshtras algorithm.
Theory:
Dijkstra's algorithm, conceived by Dutch computer scientist Edsger Dijkstra in 1956 and published in 1959, is a graph search algorithm that solves the single-source shortest path problem for a graph with nonnegative edge path costs, producing a shortest path tree. This algorithm is often used in routing and as a subroutine in other graph algorithms.
For a given source vertex (node) in the graph, the algorithm finds the path with lowest cost (i.e. the shortest path) between that vertex and every other vertex. It can also be used for finding costs of shortest paths from a single vertex to a single destination vertex by stopping the algorithm once the shortest path to the destination vertex has been determined. For example, if the vertices of the graph represent cities and edge path costs represent driving distances between pairs of cities connected by a direct road, Dijkstra's algorithm can be used to find the shortest route between one city and all other cities. As a result, the shortest path first is widely used in network routing protocols, most notably IS-IS and OSPF (Open Shortest Path First).
Dijkstra's original algorithm does not use a min-priority queue and runs in O(|V|2). The idea of this algorithm is also given in (Leyzorek et al. 1957). The common implementation based on a min-priority queue implemented by a Fibonacci heap and running in O(|E| + |V| log |V|) is due to (Fredman & Tarjan 1984). This is asymptotically the fastest known single-source shortest-path algorithm for arbitrary directed graphs with unbounded nonnegative weights.
Let the node at which we are starting be called the initial node. Let the distance of node Y be the distance from the initial node to Y. Dijkstra's algorithm will assign some initial distance values and will try to improve them step by step.
  1. Assign to every node a tentative distance value: set it to zero for our initial node and to infinity for all other nodes.
  2. Mark all nodes unvisited. Set the initial node as current. Create a set of the unvisited nodes called the unvisited set consisting of all the nodes except the initial node.
  3. For the current node, consider all of its unvisited neighbors and calculate their tentative distances. For example, if the current node A is marked with a distance of 6, and the edge connecting it with a neighbor B has length 2, then the distance to B (through A) will be 6+2=8. If this distance is less than the previously recorded distance, then overwrite that distance. Even though a neighbor has been examined, it is not marked as visited at this time, and it remains in the unvisited set.
  4. When we are done considering all of the neighbors of the current node, mark the current node as visited and remove it from the unvisited set. A visited node will never be checked again; its distance recorded now is final and minimal.
  5. If the destination node has been marked visited (when planning a route between two specific nodes) or if the smallest tentative distance among the nodes in the unvisited set is infinity (when planning a complete traversal), then stop. The algorithm has finished.
  6. Set the unvisited node marked with the smallest tentative distance as the next "current node" and go back to step 3.


Suppose you want to find the shortest path between two intersections on a city map, a starting point and a destination. The order is conceptually simple: to start, mark the distance to every intersection on the map with infinity. This is done not to imply there is an infinite distance, but to note that that intersection has not yet been visited; some variants of this method simply leave the intersection unlabeled. Now, at each iteration, select a current intersection. For the first iteration the current intersection will be the starting point and the distance to it (the intersection's label) will be zero. For subsequent iterations (after the first) the current intersection will be the closest unvisited intersection to the starting point—this will be easy to find.
From the current intersection, update the distance to every unvisited intersection that is directly connected to it. This is done by determining the sum of the distance between an unvisited intersection and the value of the current intersection, and relabeling the unvisited intersection with this value if it is less than its current value. In effect, the intersection is relabeled if the path to it through the current intersection is shorter than the previously known paths. To facilitate shortest path identification, in pencil, mark the road with an arrow pointing to the relabeled intersection if you label/relabel it, and erase all others pointing to it. After you have updated the distances to each neighboring intersection, mark the current intersection as visited and select the unvisited intersection with lowest distance (from the starting point) -- or lowest label—as the current intersection. Nodes marked as visited are labeled with the shortest path from the starting point to it and will not be revisited or returned to.
Continue this process of updating the neighboring intersections with the shortest distances, then marking the current intersection as visited and moving onto the closest unvisited intersection until you have marked the destination as visited. Once you have marked the destination as visited (as is the case with any visited intersection) you have determined the shortest path to it, from the starting point, and can trace your way back, following the arrows in reverse.
Of note is the fact that this algorithm makes no attempt to direct "exploration" towards the destination as one might expect. Rather, the sole consideration in determining the next "current" intersection is its distance from the starting point. In some sense, this algorithm "expands outward" from the starting point, iteratively considering every node that is closer in terms of shortest path distance until it reaches the destination. When understood in this way, it is clear how the algorithm necessarily finds the shortest path, however it may also reveal one of the algorithm's weaknesses: its relative slowness in some topologies.
In the following algorithm, the code u := vertex in Q with smallest dist[], searches for the vertex u in the vertex set Q that has the least dist[u] value. That vertex is removed from the set Q and returned to the user. dist_between(u, v) calculates the length between the two neighbor-nodes u and v. The variable alt on line 15 is the length of the path from the root node to the neighbor node v if it were to go through u. If this path is shorter than the current shortest path recorded for v, that current path is replaced with this alt path. The previous array is populated with a pointer to the "next-hop" node on the source graph to get the shortest route to the source.
 1  function Dijkstra(Graph, source):
 2      for each vertex v in Graph:            // Initializations
 3          dist[v] := infinity ;           // Unknown distance function from source to v
 4          previous[v] := undefined ;     // Previous node in optimal path from source
 5      end for ;
 6      dist[source] := 0 ;                    // Distance from source to source
 7      Q := the set of all nodes in Graph ;   // All nodes in the graph are unoptimized - thus are in Q
 8      while Q is not empty:                  // The main loop
 9          u := vertex in Q with smallest distance in dist[] ;
10          if dist[u] = infinity:
11              break ;          // all remaining vertices are inaccessible from source
12          end if ;
13          remove u from Q ;
14          for each neighbor v of u:          // where v has not yet been removed from Q.
15              alt := dist[u] + dist_between(u, v) ;
16              if alt < dist[v]:              // Relax (u,v,a)
17                  dist[v] := alt ;
18                  previous[v] := u ;
19                  decrease-key v in Q;       // Reorder v in the Queue
20              end if ;
21          end for ;
22      end while ;
23      return dist[] ;
24  end Dijkstra.
If we are only interested in a shortest path between vertices source and target, we can terminate the search at line 13 if u = target. Now we can read the shortest path from source to target by iteration:
S := empty sequence
u := target
while previous[u] is defined:
4      insert u at the beginning of S
5      u := previous[u]
end while ;
Now sequence S is the list of vertices constituting one of the shortest paths from source to target, or the empty sequence if no path exists.
A more general problem would be to find all the shortest paths between source and target (there might be several different ones of the same length). Then instead of storing only a single node in each entry of previous[] we would store all nodes satisfying the relaxation condition. For example, if both r and source connect to target and both of them lie on different shortest paths through target (because the edge cost is the same in both cases), then we would add both r and source to previous [target]. When the algorithm completes, previous[] data structure will actually describe a graph that is a subset of the original graph with some edges removed. Its key property will be that if the algorithm was run with some starting node, then every path from that node to any other node in the new graph will be the shortest path between those nodes in the original graph, and all paths of that length from the original graph will be present in the new graph. Then to actually find all these short paths between two given nodes we would use a path finding algorithm on the new graph, such as depth-first search.

Coclusion :
            Dijkstra's original algorithm does not use a min-priority queue and runs in O(|V|2).







PROGRAM:
//Program for dijkstra's algorithm
import java.util.*;
class Dijkstra
{
            public static void main(String[] args)
            {
                        Scanner scr = new Scanner(System.in);
int weight[][],s,d,sp=0,n,visit[],finall=0,smalldist;
int i,j,f,INFINITY=5000,x,newdist,k=0,current,distcurr;
                        System.out.println("\nNo. of nodes in graph");
                        n=scr.nextInt();
                        weight=new int[n][n];
                        visit=new int[n];
                        int distance[]=new int[n];
                        int precede[]=new int[n];
                        int path[]=new int[n];
                        System.out.println("\nEnter  cost matrix");
                        for (i=0; i<n; i++)
                        for (j=0; j<n; j++)
                        {
                                    System.out.println("\nIs "+(i+1)+"--"+(j+1)+" present?(1/0): ");
                                    f=scr.nextInt();
                                    if (i==j||f!=1)
                                    {
                                                weight[i][j]=INFINITY;
                                    }
                                    else
                                    {
                                                System.out.println("\nEnter cost "+(i+1)+"--"+(j+1)+" : ");
                                        weight[i][j]=scr.nextInt();                                                              
                                    }
                        }
                        System.out.print("\nEnter the source node : ");
                        s=scr.nextInt();
                        System.out.print("\nEnter the destination node : ");
                        d=scr.nextInt();

                        for (i=0;i<n;i++)
                        {
                                    distance[i]=INFINITY;
                                    precede[i]=INFINITY;
                        }
                        distance[s]=0;
                        current=s;
                        visit[current]=1;
                        while(current!=d)
                        {
                                    distcurr=distance[current];
                                    smalldist=INFINITY;
                                    for(i=0; i<n; i++)
                                    {
                                                if(visit[i]==0)
                                                {
                                                            newdist=distcurr+weight[current][i];
                                                            if(newdist<distance[i])
                                                            {
                                                                        distance[i]=newdist;
                                                                        precede[i]=current;
                                                            }
                                                            if(distance[i]< smalldist)
                                                            {
                                                                        smalldist=distance[i];
                                                                        k=i;
                                                            }
                                                }
                                    }
                                    current = k;
                                    visit[current]=1;
                        }
                        i=d;
                        path[finall]=d;
                        finall++;
                        while(precede[i] != s)
                        {
                        j = precede[i];
                        i = j;
                        path[finall] = i;
                        finall++;
                        }
                        path[finall] = s;
                        System.out.println("\nThe shortest path followed is : \n\n");
                        for(i=finall;i>0;i--)
                        System.out.print("\t\t( "+ path[i]+" ->"+path[i-1]+" ) with cost = ");
                        System.out.print(weight[path[i]][path[i-1]]+"\n\n");
                        System.out.println("For the Total Cost = "+distance[d]);
                        }
}
Output:
No. of nodes in graph: 3
Enter  cost matrix
Is 1--1 present?(1/0):
0
Is 1--2 present?(1/0):
2
Is 1--3 present?(1/0):
10
Is 2--1 present?(1/0):
3
Is 2--2 present?(1/0):
0
Is 2--3 present?(1/0):
1
Enter cost 2--3 :
3
Is 3--1 present?(1/0):
0
Is 3--2 present?(1/0):
0
Is 3--3 present?(1/0):
0
Enter the source node : 1
Enter the destination node : 3
The shortest path followed is :
1 -> 2 -> 3
For the Total Cost = 5