Question

***** running late, mere 3 hours left for due time, please help **

#needed in c++

#inputfile

MinPath2.txt

0   SF
1   LA
2   DALLAS
3   CONCORD
4   PHOENIX
5   CHICAGO
6   ST LOUIS
7   BOSTON
8   NY
9   LONDON
10   PARIS
11   TOKYO
12   BANGKOK
13   MEXICO CITY
14   MONTREAL
-1  
0   1   40
0   2   100
0   4   130
0   8   200
0   9   800
0   10   900
1   2   50
1   3   80
1   4   70
1   8   400
1   10   1200
1   12   900
2   6   120
2   7   110
2   13   700
2   14   600
3   5   30
3   6   50
3   8   450
4   5   50
4   8   300
4   13   350
5   7   40
5   8   100
5   9   475
5   11   650
6   7   60
6   8   195
6   14   80
7   8   65
7   9   425
7   10   700
7   14   325
8   9   325
8   10   600
8   11   700
8   12   550
9   10   60
9   12   400
10   13   200
11   12   125
11   13   400
12   13   350
13   14   700
-1

##Graphs

Min path

DESCRIPTION

Write a program that will display the minimum path between any two vertices in a given graph. The program will input the graph from a file provided by the user. It will prompt the user for entering the name of the start vertex and the end vertex. It will find the minimum path between the two vertices. It will display the minimum path showing all the vertices along the path. It will also display the total distance along the minimum path.

TESTING

Test the program for two data sets included in this module as text files. For each data set, carry out a number of test runs as listed below.

Data Set 1

Test the program for the data set 1 listed. Enter this data into a file and input the data from the file.

The data consists of two parts. In the first part, each line represents a vertex. It contain two values. The first value specifies the vertex number. The second value specifies the vertex name. The first part ends when a line contains -1 by itself. In the second part, each line represents an edge. It contains three values. The first two values specify two vertices connecting the edge. The third value specifies the weight of the edge. This part ends when a line contains -1 by itself.

0 SF

1 LA

2 CHICAGO

3 NY

4 PARIS

5 LONDON

-1

0 1 80

0 2 200

0 3 300

1 2 230

1 5 700

2 3 180

3 4 630

3 5 500

4 5 140

-1

Data Set 1: Test Run 1

Run the program using SF as the start vertex. Program input/output dialog is shown below. The user input is shown in bold.

Enter Start Vertex: SF

Enter End Vertex :LONDON

Min Path: SF LA LONDON 780

Data Set 1: Test Run 2

Enter Start Vertex: SF

Enter End Vertex : PARIS

Min Path: SF LA LONDON PARIS 920

Data Set 2:

Data set 2 is available in a file attached.

For data set 2, run the program several times: each time use the same vertex (the first vertex input) as the start vertex and a different vertex as the destination vertex till each vertex has been used as the destination vertex.

IMPLEMENTATION

MinPath algorithm finds the minimum path from a specified start vertex to a specified target (destination) vertex in a graph and displays the following.

The list of all the vertices in the minimum path from the start vertex to the target vertex.

The total distance from the start vertex to the target vertex along the above path.

Methodology

MinPath algorithm accomplishes the above by using a variation of BreadthFirst traversal algorithm covered in a previous assignment with the following additional provisions.

It uses a priority queue (PmainQ) instead of a regular queue.

In the queue, it enqueues a vertex as an item describing the vertex.  The vertex item contains the following fields:

• Total Accumulated Distance: The total distance from the start vertex to this vertex.
• Path List: The list of all vertices in the path from the start vertex to this vertex.  The list of vertices is stored as an array of ints (vertex numbers).
• Path Length: The length of the above array.

In the priority queue (PmainQ), the vertex items are enqueued in ascending order of the Total Accumulated Distance values in the item vertices.

The item vertices are enqueued and dequeued form the PmainQ using a procedure similar to the BreadthFirst algorithm and is presented below.

You may use the code below as a guidance – but I strongly encourage you to design your own algorithm

1. Enqueue the start vertex item in the priority queue: PmainQ.
2. Repeatedly: dequeue a vertex item and enqueue its adjacent vertex items as below

until the target vertex is found or the PmainQ becomes empty.

Dequeue a vertex item.

If (the dequeued vertex item is the target vertex item or PmainQ is empty)

go to step 3

Else

     If it is not previously Marked Visited

Mark it “visited”.

Get a list of all its adjacent vertices.

Enqueue all adjacent vertices that are not previously marked visited into the PMainQ.

Algorithm

//The above methodology is presented below as an algorithm.

Enque the start vertex item in the PmainQ.

While ( !( PmainQ.isEmpty() ) )

{

          Deque a vertex item from the PmainQ.

//Process the vertex item dequeued as follows.

If( vertex is unmarked )

{

          If ( vertex is the target vertex )

                   break from the loop;

Mark the vertex as visited.

//Get a list of all its adjacent vertices by calling a method (say getAdjacent ) as below.

//(Note: getAdjacent returns adjacent vertices in a queue, adjacentQ, passed to it as below).

//(Note: getAdjacent returns vertices in order with the lowest numbered vertex first).                                                                                                           

          getAdjacent (vertex, adjacentQ)

          //Process the adjacent vertices by dequeing them from the adjacent queue

//and enqueueing them in PmainQ as below.

          While ( !( adjacentQ.isEmpty() ) )

          {

                   Dequeue a vertex from adjacentQ.

                   If( adjacent vertex is unmarked )

                   {

                             Enqueue the adjacent vertex item in the PmainQ.

                   }

          }

          }

}

If the target vertex item is found,

      Display the item contents including:

The total distance from the start vertex to the target vertex.

The list of all vertices along the above path.

          Else

     Display message: “Vertex Not Found”.

SUBMIT YOUR SOURSE CODE AND ENOUFG SCREEN SHOTS OF THE OUTPUT PROVING YOUR ALGORITHM IS WORKING

Answer 1

PROGRAM:

#include<iostream>

#include<vector>

#include<string>

#include<list>

#include<algorithm>

#include<fstream>

using namespace std;

vector<pair<int, int> > adj[6];

int V = 6;

void addEdge(vector <pair<int, int> > adj[], int u,

int v, int wt)

{

adj[u].push_back(make_pair(v, wt));

adj[v].push_back(make_pair(u, wt));

}

// Print adjacency list representaion ot graph

void printGraph(vector<pair<int, int> > adj[], int V)

{

int v, w;

for (int u = 0; u < V; u++)

{

cout << u << " - ";

for (auto it = adj[u].begin(); it != adj[u].end(); it++)

{

v = it->first;

w = it->second;

cout << v << " ="

<< w << "\n";

}

cout << "\n";

}

}

// This function mainly does BFS and prints the

// shortest path from src to dest. It is assumed

// that weight of every edge is 1

int findShortestPath(int src, int dest)

{

// Mark all the vertices as not visited

bool *visited = new bool[2 * V];

int *parent = new int[2 * V];

static int total = 0;

// Initialize parent[] and visited[]

for (int i = 0; i < 2 * V; i++)

{

visited[i] = false;

parent[i] = -1;

}

// Create a queue for BFS

list<int> queue;

// Mark the current node as visited and enqueue it

visited[src] = true;

queue.push_back(src);

while (!queue.empty())

{

// Dequeue a vertex from queue and print it

int s = queue.front();

if (s == dest)

return total;

queue.pop_front();

// Get all adjacent vertices of the dequeued vertex s

// If a adjacent has not been visited, then mark it

// visited and enqueue it

for (auto it = adj[s].begin(); it != adj[s].end(); it++)

{

if (!visited[it->first])

{

visited[it->first] = true;

queue.push_back(it->first);

total += it->second;

parent[it->first] = s;

}

}

}

return total;

}

// Driver code

int main()

{

string line;

ifstream myfile("file.txt");

vector<string> vertex;

int count = 1,V;

vector<pair<int, int> > adj[6];

if (myfile.is_open())

{

while (getline(myfile, line))

{

//cout << line << '\n';

while (line != "-1")

{

char *token = strtok(const_cast<char*>(line.c_str()), " ");

token = strtok(NULL, " ");

vertex.push_back(token);

getline(myfile, line);

}

V = vertex.size();

getline(myfile, line);

while (line != "-1")

{

char *token = strtok(const_cast<char*>(line.c_str()), " ");

int u = atoi(token);

int v = atoi(strtok(NULL, " "));

int w = atoi(strtok(NULL, " "));

addEdge(adj, u, v, w);

getline(myfile, line);

}

}

myfile.close();

}

else cout << "Unable to open file";

string start, end;

cout << "Enter Start Vertex : ";

cin >> start;

cout << "Enter End Vertex : ";

cin >> end;

int s, e;

int i = 0;

for (auto it = vertex.begin(); it != vertex.end(); it++)

{

if (*it == start) s = i;

if (*it == end) e = i;

i++;

}

cout << findShortestPath(s, e) << endl;

printGraph(adj, V);

system("pause");

return 0;

}