Breaking News: Grepper is joining You.com. Read the official announcement!

Shortest Path in Undirected Graphs

Raghav Bansal answered on November 19, 2022 Popularity 9/10 Helpfulness 1/10

answer Shortest Path in Undirected Graphs

Shortest Path in Undirected Graphs

Comment

//C++ program to find the Shortest Path in an Unweighted Graph
#include <bits/stdc++.h>
using namespace std;
// Graph class implemented using an adjacency list

class Graph{

public:
    int V;  // Number of Vertices
    int E;  // Number of Edges
    vector<int> *adj; // adjacency list
    Graph(int num_vertices, int num_edges){
        this->V = num_vertices;
        this->E = num_edges;
        this->adj = new vector<int>[num_vertices];
    }
    // function to add Edge
void addEdge(int u, int v){
        adj[u-1].push_back(v-1);
        adj[v-1].push_back(u-1);
 }

    // function to compute all paths
void computeAllPaths(int src, int dest, vector<int> &path, vector<bool> &vis, vector<vector<int>> &paths){
        if(vis[src]){   // if this node is already visited then return
            return ;
        }
        // if src == dest means that we have reached the destination and found the path
        if(src == dest){
            path.push_back(src);
            paths.push_back(path);
            path.pop_back();
            return;
        }
        // mark current node as visited
        vis[src] = 1;
        path.push_back(src);
        // traverse the path via current node's adjacent nodes
        for(int node: this->adj[src]){
            if(!vis[node]){  // if adjacent node is not visited
                // path.push_back(node);    // push to the possible path list
                computeAllPaths(node, dest, path, vis, paths); // recursively traverse path
                // path.pop_back(); // pop_back from the possible path list
            }
        }
        vis[src] = 0; // mark current node as unvisited
        path.pop_back(); // pop the current source node
    }

    // function that prints out the shortest path     
void ShortestPath(int src, int dest){
       vector<int> path;   // possible path list
       vector<bool> vis(V, 0); // visited list
       vector<vector<int>> paths; // list of all paths from src to dest
       computeAllPaths(src, dest, path, vis, paths); // find All paths
       vector<int> Shortest_path; // vector to store the Shortest_path
       for(vector<int> v: paths){
           // find the Shortest_path
           if(Shortest_path.size()==0 or (Shortest_path.size()>v.size())){
               Shortest_path = v;
           }
       }
       cout<<"The Shortest Path of the Unweighted Graph is: ";
       // print the shortest path
       for(int i=0;i<Shortest_path.size();++i){
           if(i!=Shortest_path.size()-1){
               cout<<Shortest_path[i]+1<<" -> ";
           }else{
               cout<<Shortest_path[i]+1<<'\n';
           }
       }
       cout<<"The length is "<<Shortest_path.size();
    }
};

int main() {
    // Number of Edges and Vertices
	int num_vertices = 8;
	int num_edges = 9;
	Graph G(num_vertices, num_edges); // Graph G
    // add all edges to graph
	G.addEdge(1, 2);
	G.addEdge(2, 1);
	G.addEdge(1, 3);
	G.addEdge(3, 1);
	G.addEdge(1, 4);
	G.addEdge(4, 1);
	G.addEdge(3, 8);
	G.addEdge(8, 3);
	G.addEdge(5, 2);
	G.addEdge(2, 5);
	G.addEdge(4, 6);
	G.addEdge(6, 4);
	G.addEdge(7, 6);
	G.addEdge(6, 7);
	G.addEdge(5, 8);
	G.addEdge(8, 5);
	G.addEdge(8, 7);
	G.addEdge(7, 8);
	// compute the Shortest_path
	int src = 1; int dest = 8;
	G.ShortestPath(src-1, dest-1); // 0-based indexing
	return 0;
}

Popularity 9/10 Helpfulness 1/10 Language cpp

Source: www.codingninjas.com

Tags: c++ shortest-path

Link to this answer
Share Copy Link

Contributed on Nov 19 2022

Raghav Bansal

0 Answers Avg Quality 2/10

Shortest Path in Undirected Graphs

Contents

More Related Answers

Shortest Path in Undirected Graphs

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.