how to use Dijkstra c++ code using array based version

Question

I need to use (not implement) an array based version of Dijkstras algo .The task is that given a set of line segments(obstacles) and start/end points I have to find and draw the shortest path from start/end point.I have done the calculating part etc..but dont know how to use dijkstras with my code.My code is as follows

class Point
{
public:
int x;
int y;
Point()
{

}

void CopyPoint(Point p)
{
this->x=p.x;
this->y=p.y;
}
};

class NeighbourInfo
{
public:
Point x;
Point y;
double distance;

NeighbourInfo()
{
distance=0.0;
}
};


class LineSegment
{
 public:
 Point Point1;
 Point Point2;
 NeighbourInfo neighbours[100];

 LineSegment()
 {

 }




 void main()//in this I use my classes and some code to fill out the datastructure
 {

 int NoOfSegments=i;

 for(int j=0;j<NoOfSegments;j++)
 {
 for(int k=0;k<NoOfSegments;k++)
 {
 if( SimpleIntersect(segments[j],segments[k]) )
 {
   segments[j].neighbours[k].distance=INFINITY;
   segments[j].neighbours[k].x.CopyPoint(segments[k].Point1);
   segments[j].neighbours[k].y.CopyPoint(segments[k].Point2);
   cout<<"Intersect"<<endl;
   cout<<segments[j].neighbours[k].distance<<endl;
 }
else
{
   segments[j].neighbours[k].distance=
EuclidianDistance(segments[j].Point1.x,segments[j].Point1.y,segments[k].Point2.x,segments[k    ].Point2.y);
   segments[j].neighbours[k].x.CopyPoint(segments[k].Point1);
   segments[j].neighbours[k].y.CopyPoint(segments[k].Point2);

}
}
}

}

Now I have the distances from each segmnets to all other segments, amd using this data(in neighbourinfo) I want to use array based Dijkstras(restriction ) to trace out the shortest path from start/end points.There is more code , but have shortened the problem for the ease of the reader

Please Help!!Thanks and plz no .net lib/code as I am using core C++ only..Thanks in advance

But I need the array based version(strictly..) I am not suppose to use any other implemntation.

Answer 1

Dijkstras

This is how Dijkstra's works:
Its not a simple algorithm. So you will have to map this algorithm to your own code.
But good luck.

List<Nodes>    found;     // All processed nodes;
List<Nodes>    front;     // All nodes that have been reached (but not processed)
                          // This list is sorted by the cost of getting to this node.
List<Nodes>    remaining; // All nodes that have not been explored.

remaining.remove(startNode);
front.add(startNode);
startNode.setCost(0); // Cost nothing to get to start.

while(!front.empty())
{
    Node       current = front.getFirstNode();
    front.remove(current);
    found.add(current);

    if (current == endNode)
    {    return current.cost(); // we found the end
    }

    List<Edge> edges   = current.getEdges();

    for(loop = edges.begin(); loop != edges.end(); ++loop)
    {
        Node   dst = edge.getDst();
        if (found.find(dst) != found.end())
        {   continue; // If we have already processed this node ignore it.
        }


        // The cost to get here. Is the cost to get to the last node.
        // Plus the cost to traverse the edge.
        int    cost = current.cost() + loop.cost();
        Node   f    = front.find(dst);
        if (f != front.end())
        {
            f.setCost(std::min(f.cost(), cost));
            continue;  // If the node is on the front line just update the cost
                       // Then continue with the next node.
        }

        // Its a new node.
        // remove it from the remaining and add it to the front (setting the cost).
        remaining.remove(dst);
        front.add(dst);
        dst.setCost(cost);
    }
}