Dijkstra's algorithm solves the single-source shortest-path problem when all edges

have non-negative weights. It is a greedy algorithm and similar to Prim's algorithm.

Algorithm starts at the source vertex, s, it grows a tree, T, that ultimately spans all
vertices reachable from S. Vertices are added to T in order of distance i.e., first S, then
the vertex closest to S, then the next closest, and so on. Following implementation
assumes that graph G is represented by adjacency lists.

DIJKSTRA (G, w, s)
1. INITIALIZE SINGLE-SOURCE (G, s)
2. S ← { }     // S will ultimately contains vertices of final
shortest-path weights from s
3. Initialize priority queue Q i.e., Q  ←  V[G]
4. while priority queue Q  is not empty do
5.     u  ←  EXTRACT_MIN(Q)    // Pull out new vertex
6.     S  ←  S{u}
    // Perform relaxation for each vertex v adjacent to u
7.     for each vertex v in Adj[u] do
8.         Relax (u, v, w)
 

Example: Step by Step operation of Dijkstra algorithm.

 

Step1. Given initial graph G=(V, E). All nodes nodes have infinite cost except the
source node, s,  which has 0 cost.
Step 2. First we choose the node, which is closest to the source node, s. We initialize
d[s] to 0. Add it to S. Relax all nodes adjacent to source, s. Update predecessor (see
red arrow in diagram below) for all nodes updated.

Step 3. Choose the closest node, x. Relax all nodes adjacent to node x. Update
predecessors for nodes u, v and y (again notice red arrows in diagram below).

Step 4. Now, node y is the closest node, so add it to S. Relax node v and adjust its
predecessor (red arrows remember!).
Step 5. Now we have node u that is closest. Choose this node and adjust its neighbor
node v.

Step 6. Finally, add node v. The predecessor list now defines the shortest path from
each node to the source node, s.

 
Q as a linear array
EXTRACT_MIN takes O(V) time and there are |V| such operations. Therefore, a
2
total time for EXTRACT_MIN in while-loop is O(V ). Since the total number of
edges in all the adjacency list is |E|. Therefore for-loop iterates |E| times with each
iteration taking O(1) time. Hence, the running time of the algorithm with array
2
implementation is O(V  + E) = O(V2).
 

Q as a binary heap ( If G is sparse)

In this case, EXTRACT_MIN operations takes O(lg V) time and there are |V|such
operations.
The binary heap can be build in O(V) time.
Operation DECREASE (in the RELAX) takes O(lg V) time and there are at most
such operations.
Hence, the running time of the algorithm with binary heap provided given graph is
sparse is O((V + E) lg V). Note that this time becomes O(ElgV) if all vertices
in the graph is reachable from the source vertices.

Q as a Fibonacci heap
In this case, the amortized cost of each of |V| EXTRAT_MIN operations if O(lg V).
Operation DECREASE_KEY in the subroutine RELAX now takes only O(1)
amortized time for each of the |E| edges.
As we have mentioned above that Dijkstra's algorithm does not work on the digraph
with negative-weight edges. Now we give a simple example to show that Dijkstra's
algorithm produces incorrect results in this situation. Consider the digraph consists of
V = {s, a, b} and E = {(s, a), (s, b), (b, a)} where w(s, a) = 1, w(s, b) = 2, and w(b, a) =
-2.
Dijkstra's algorithm gives d[a] = 1, d[b] = 2. But due to the negative-edge weightw(b,
a), the shortest distance from vertex s to vertex a is 1-2 = -1.

From Wikipedia, the free encyclopedia

flooding algorithm

flooding algorithm with ack messages

A flooding algorithm is an algorithm for distributing material to every part of a connected network. The name derives

from the concept of inundation by aflood.

Flooding algorithms are used in systems such as Usenet and peer-to-peer file sharing systems and as part of

some routing protocols, including OSPF,DVMRP, and those used in ad-hoc wireless networks.

There are several variants of flooding algorithm: most work roughly as follows.

1. Each node acts as both a transmitter and a receiver.

2. Each node tries to forward every message to every one of its neighbors except the source node.

This results in every message eventually being delivered to all reachable parts of the network.
Real-world flooding algorithms have to be more complex than this, since precautions have to be taken to avoid

wasted duplicate deliveries and infinite loops, and to allow messages to eventually expire from the system.

Flooding algorithms are also useful for solving many mathematical problems, including maze problems and many

problems in graph theory.

Contents

 [hide]

1 Disadvantages of

Flooding

2 Advantages of

Flooding

3 See also

4 Examples

[edit]Disadvantages of Flooding

There are several disadvantages with this approach to routing. It is very wasteful in terms of the networks total

bandwidth. While a message may only have one destination it has to be sent to every host. This increases the

maximum load placed upon the network.

Messages can also become duplicated in the network further increasing the load on the networks bandwidth as well

as requiring an increase in processing complexity to disregard duplicate messages.

A variant of flooding called selective flooding partially addresses these issues by only sending packets to routers in

the same direction.

[edit]Advantages of Flooding

The main advantage of flooding is the increased reliability provided by this routing method. Since the message will be

sent at least once to every host it is almost guaranteed to reach its destination. In addition, the message will reach

the host through the shortest possible path.