Create the following operations and include a menu-driven main program that will demonstrate your operations. The program will only stop when the user chooses 5 Exit Program. Create Graph a. Adjacency...

1. Create Graph
   a. Adjacency List(Programmer2)
   
   b. Adjacency Matrix(Programmer2)
   


2. Traversal (User will input the source / start)
   a. BFS(Lead Programmer)
   
   b. DFS(Lead Programmer)
   


3. Find Path (Given source and destination)(Programmer2)
   


4. Path Cost (Given source and destination)(Lead Programmer)
   


5. Exit Program(Programmer1)
   


6. Main Program(Programmer1)
   
   
   Make necessary changes to this given codes
   
   
   Main.cpp
   

   #include
   #include "Data.h"
   using namespace std;

   
   

   int main()
   {
   int ch;
   Graph g(8);
   cout < "graph="" operations"=""><>
   cout < "[1]="" adjacency="" list"=""><>
   cout < "[2]="" adjacency="" matrix"=""><>
   cout < "enter="" choice:="">
   cin >> ch;
   if (ch == 1)
   {
   g.addEdge(0, 6);
   g.addEdge(1, 5);
   g.addEdge(2, 0);
   g.addEdge(2, 4);
   g.addEdge(3, 5);
   g.addEdge(4, 1);
   g.addEdge(4, 3);
   g.addEdge(5, 7);
   g.addEdge(6, 1);
   g.addEdge(6, 7);
   g.printGraph();
   cout < endl="">< "dfs="" traversal..."=""><>
   g.DFS(1);
   cout < endl=""><>
   cout < endl="">< "bfs="" traversal..."=""><>
   g.BFS(3);
   }
   else if (ch == 2)
   {
   g.addEdge2(0, 6);
   g.addEdge2(1, 5);
   g.addEdge2(2, 0);
   g.addEdge2(2, 4);
   g.addEdge2(3, 5);
   g.addEdge2(4, 1);
   g.addEdge2(4, 3);
   g.addEdge2(5, 7);
   g.addEdge2(6, 1);
   g.addEdge2(6, 7);
   g.printGraph2();
   }
   cout < endl=""><>
   }

   
   

   Data.h

   
   

   #pragma once
   #include
   #include
   using namespace std;

   
   

   
   
   class Graph
   {
   private:
   int V;
   list *adj; //Programmer2
   int **adj2; //Programmer2
   void DFSUtil(int v, bool visited[]); //Lead
   void BFSUtil(int s, bool visited[]); //Lead

   
   

   public:
   Graph(int); //All
   
   void addEdge(int u, int v); //All
   void addEdge2(int u, int v); //Programmer2
   void printGraph(); //All
   void printGraph2(); //Programmer2
   void DFS(int v); //Lead
   void BFS(int s); //Lead
   };
   
   
   
   

   
   Implementation.cpp
   

   #include
   #include
   #include "Data.h"
   using namespace std;

   
   

   Graph::Graph(int x)
   {
   V = x;
   adj = new list [V];
   adj2 = new int* [V];
   for (int i = 0; i < v;="">
   adj2[i] = new int[V];
   for (int i = 0; i < v;="">
   for (int j = 0; j < v;="">
   adj2[i][j] = 0;

   
   

   }

   
   

   void Graph::addEdge(int u, int v)
   {
   adj[u].push_back(v);
   }

   
   

   void Graph::addEdge2(int u, int v)
   {
   adj2[u][v] = 1;
   }

   
   

   // A utility function to print the adjacency list
   
   // representation of graph
   
   void Graph::printGraph()
   {
   cout < "adjacency="" list..."=""><>
   for (int v = 0; v < v;="">
   {
   cout < "v["="">< v=""><>
   for (auto x : adj[v])
   cout < "="" -=""> " <>
   cout <>
   }
   }

   
   

   void Graph::printGraph2()
   {
   cout < "adjacency="" matrix..."="">< endl=""><>
   cout <>
   for (int i = 0; i < v;="">
   cout < "v["="">< i="">< "]"=""><>
   cout <>
   for (int i=0; i
   {
   cout < "v["="">< i="">< "]"=""><>
   for (int j = 0; j < v;="">
   cout < adj2[i][j]=""><>
   cout <>
   }
   cout <>
   }

   
   

   void Graph::DFSUtil(int v, bool visited[])
   {
   // Mark the current node as visited and
   
   // print it
   
   visited[v] = true;
   cout < v="">< "="">

   
   

   // Recur for all the vertices adjacent
   
   // to this vertex
   
   list::iterator i;
   for (i = adj[v].begin(); i != adj[v].end(); ++i)
   if (!visited[*i])
   DFSUtil(*i, visited);
   }

   
   

   // DFS traversal of the vertices reachable from v.
   
   // It uses recursive DFSUtil()
   
   void Graph::DFS(int v)
   {
   // Mark all the vertices as not visited
   
   bool *visited = new bool[V];
   for (int i = 0; i < v;="">
   visited[i] = false;

   
   

   // Call the recursive helper function
   
   // to print DFS traversal
   
   
   
   DFSUtil(v, visited);
   for(int i=0; i< v;="">
   if (!visited[i])
   DFSUtil(i, visited);

   
   

   for (int i = 0; i < v;="">
   if (!visited[i])
   cout < i="">< "="">
   }

   
   

   void Graph::BFS(int s)
   {
   // Mark all the vertices as not visited
   
   bool *visited = new bool[V];
   for (int i = 0; i < v;="">
   visited[i] = false;

   
   

   BFSUtil(s, visited);
   for (int i = 0; i < v;="">
   if (!visited[i])
   BFSUtil(i, visited);

   
   

   for (int i = 0; i < v;="">
   if (!visited[i])
   cout < i="">< "="">
   }

   
   

   void Graph::BFSUtil(int s, bool visited[])
   {
   // Create a queue for BFS
   
   list queue;

   
   

   // Mark the current node as visited and enqueue it
   
   visited[s] = true;
   queue.push_back(s);

   
   

   // 'i' will be used to get all adjacent
   
   // vertices of a vertex
   
   list::iterator i;

   
   

   while (!queue.empty())
   {
   // Dequeue a vertex from queue and print it
   
   s = queue.front();
   cout < s="">< "="">
   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 (i = adj[s].begin(); i != adj[s].end(); ++i)
   {
   if (!visited[*i])
   {
   visited[*i] = true;
   queue.push_back(*i);
   }
   }
   }
   }

   
   

Extracted text: Dallas 200 200 1300 Austin Washington Denver 1400 Atlanta Chicago Houston 009 6000 008 160 0000 7000 0001 O06


Extracted text: Make necessary changes to the Class Definition Graph ADT so that it can store data in the following way: (a) Pointer to next edge node Index of edge nodes Weight adjacent vertex graph 101 "Atlanta 6 600 800 11 "Austin 121 "Chicago 3. 200 160 4 1000 131 "Dallas 1 200 2 900 780 (41 Denver 01400 2 1000 [51 Houston 800 (61 "Washington" 0 600 . 1300 171 [8] 19) in