//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;

}