Calculating The Shortest Route Between Two Points

I have been working in the past weeks on a multiplayer HTML5 game, using nodejs and websockets. I've been stuck in this problem for a little while. Imagine that I have this tileshe

Solution 1:

This is a common graph theory problem algorithm

In graph theory, the shortest path problem is the problem of finding a path between two vertices (or nodes) in a graph such that the sum of the weights of its constituent edges is minimized.

The problem of finding the shortest path between two intersections on a road map (the graph's vertices correspond to intersections and the edges correspond to road segments, each weighted by the length of its road segment) may be modeled by a special case of the shortest path problem in graphs.

For now exists lot of implementations of this algorithm. More simpler in implementation is a Dijkstra's algorithm with worst case performance as O(|E|+|V|log|V|) where

• |V| is the number of nodes
• |E| is the number of edges

Illustration of algorithm work

Definition of Dijkstra's Shortest Path Algorithm

• initial node - the node at which we are starting.
• distance of node Y - be the distance from the initial node to Y.

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 0 for our initial node and to ∞ for all other nodes.

2. Set the initial node as current. Mark all other nodes unvisited. Create a set of all the unvisited nodes called the unvisited set.

3. For the current node, consider all of its unvisited neighbors and calculate their tentative distances. Compare the newly calculated tentative distance to the current assigned value and assign the smaller one.

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.

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 ∞ (when planning a complete traversal; occurs when there is no connection between the initial node and remaining unvisited nodes), then stop. The algorithm has finished.

6. Otherwise, select the unvisited node that is marked with the smallest tentative distance, set it as the new "current node", and go back to step 3.

More implementations of Dijkstra algorithm you can find on github repository mburst/dijkstras-algorithm.

For example here is JavaScript implementation

Solution 2:

While dijkstra algorithm definitely works, in your case the graph is an unweighted graph, so a simple BFS should suffice.

Pseudo code:

queue = [startingposition]
prev = [-1, -1, -1 ...] (arrayof n elements, all-1)
while (queue notempty) 
   u <- pop(queue)
   if u = targetposition then DONE! trace the *prev*arrayfor path
   for (v inevery unvisited points adjacent to u):
      prev[v] = u
      push v to queue
   endforend while

The prev array can also be used to check if a point is visited.

Solution 3:

Here there is no condition of calculating path cost because all path cost is 1. So you can run here normal 2D BFS algorithm and the complexity will be O(V+E)(vertex and edge).

Here every node has two property. One is row and other is column. So u can create a pair for denoting the value of a cell. Here is the c++ code and explanation:

#define pii pair<int,int>int fx[]={1,-1,0,0}; //Direction array for moving one cell to another cell horizontalyint fy[]={0,0,1,-1}; //Direction array for moving one cell to another cell verticalyint cell[100][100]; //cell[x][y] if this cell is -1 then it is block (Here it is your brown cell)int d[100][100],vis[100][100]; //d means destination from source. int row,col;
voidbfs(int sx,int sy)//Source node is in [sx][sy] cell.{
    memset(vis,0,sizeof vis);
    vis[sx][sy]=1;
    queue<pii>q; //A queue containing STL pairs
    q.push(pii(sx,sy));
    while(!q.empty())
    {       
        pii top=q.front(); q.pop();
        for(int k=0;k<4;k++)
        {
            int tx=top.uu+fx[k];
            int ty=top.vv+fy[k]; //Neighbor cell [tx][ty]if(tx>=0and tx<row and ty>=0and ty<col and cell[tx][ty]!=-1and vis[tx][ty]==0) //Check if the neighbor is valid and not visited before.
            {               
                vis[tx][ty]=1;
                d[tx][ty]=d[top.uu][top.vv]+1; 
                q.push(pii(tx,ty)); //Pushing a new pair in the queue
            }
        }
    }
}

Now you can easily find your shortest path from the d[x][y] cell.