Как выбрать 3 кратчайших путей для каждой потребности ( пара источника и усилителя; пунктом)

---

У меня есть проект в моем университете, учитывая топологию сети и список требований ( пара источника и назначения), чтобы получить все пути для каждого требования, а затем я должен выбрать 3 кратчайших пути. с тех пор как я впервые столкнулся с программированием, мне было довольно трудно понять, как это сделать правильно.

то, что я пытаюсь сделать, - это получить все доступные пути между каждой парой источников и назначением { int sources[k]={1,2,4,5}; int destinations[k]={3,4,5,1} } и в соответствии с количеством прыжков ( вершин ) каждого пути выбрать 3 самых коротких из доступных путей для каждого требования [ пары источника и назначения ].
код может получить все пути для каждого требования (т. е. s=1& d=3), но я не знаю, как выбрать из этих доступных путей 1-й кратчайший путь 3, любая помощь очень ценится. .

Что я уже пробовал:

// C++ program to print all paths from a source to destination.
	#include<iostream>
	#include <list>
	using namespace std;

	// A directed graph using adjacency list representation
	class Graph
	{
		int V; // No. of vertices in graph
		list<int> *adj; // Pointer to an array containing adjacency lists

		// A recursive function used by printAllPaths()
		void printAllPathsUtil(int , int, bool [], int [], int &);

	public:
		Graph(int V); // Constructor
		void addEdge(int u, int v);
		void printAllPaths(int s, int d);
void printShortestPaths(int s, int d);

			int k; 
			int sources;
			int destinations;
                        int id=0;  
	};

	Graph::Graph(int V)
	{
		this->V = V;
		adj = new list<int>[V];
	}

	void Graph::addEdge(int u, int v)
	{
		adj[u].push_back(v); // Add v to u’s list.
	}

	// Prints all paths from 's' to 'd'
	void Graph::printAllPaths(int s, int d)
	{
		// Mark all the vertices as not visited
		bool *visited = new bool[V];

		// Create an array to store paths
		int *path = new int[V];
		int path_index = 0; // Initialize path[] as empty
               
		// Initialize all vertices as not visited
		for (int i = 0; i < V; i++)	
                    visited[i] = false;
		// Call the recursive helper function to print all paths
		printAllPathsUtil(s, d, visited, path, path_index);            
	}

	// A recursive function to print all paths from 'u' to 'd'.
	// visited[] keeps track of vertices in current path.
	// path[] stores actual vertices and path_index is current
	// index in path[]
	void Graph::printAllPathsUtil(int u, int d, bool visited[],
                                        int path[], int &path_index)
                    {
                        int id_path[40][V-1]; //40 is an example as maximum number of paths 
                        bool id_hops[40];

                    for (int i = 0; i< 40; i++)
                        for (int j = 0; j< V-1; j++)
                            id_path [i][j]=0;
                    for (int i = 0; i< 40; i++)
                            id_hops [i]=0;
		// Mark the current node and store it in path[]
                visited[u] = true;
		path[path_index] = u;
		path_index++;
                int hops = path_index -1;
		// If current vertex is same as destination, then print
		// current path[]
		if (u == d)
                   {
                    if(hops && path)
                        id++;
                        id_hops[id-1]= hops;
                    for (int i = 0; i< path_index; i++)
                       if (path[i]!=0) 
                        id_path[id-1][i]=path[i];
                        cout << "Path_ID = " << id << " Path is : ";   
                    for (int i = 0; i< path_index; i++)
                        cout << path[i] << " ";
                        cout << "Number of hops = " << hops << endl;
                    }
		else // If current vertex is not destination
                    {
			// Recur for all the vertices adjacent to current vertex
			list<int>::iterator i;
                    for (i = adj[u].begin(); i != adj[u].end(); ++i)
			if (!visited[*i])
			printAllPathsUtil(*i, d, visited, path, path_index);
                    }

		// Remove current vertex from path[] and mark it as unvisited
                    path_index--;
                    visited[u] = false;
                    int id_Sorted[3]; //id_Sorted contains the 3 ids of the shortest paths

                for (int j=0; j<3; j++)
                    id_Sorted[j]=0;
            //we select these 3 ids
                    int min=0; //the shortest 
                for (int j=0; j<2; j++)
                   {
                    for (int i=1; i<40; i++)     
                        if ((i!= id_Sorted[0])&& (i!= id_Sorted[1]))
                            {
                                if  (id_hops[i]< id_hops[min])
                                        min=i;
                            }
                    id_Sorted[j]=min;
                    }
        //creation of id_pathShort
                    int id_pathShort[3][V-1];
                for (int j=0; j <= 2; j++)
                   {            
                    cout <<  "Path_ID_Short = " << j << " Path_short is : ";   
                        for (int i=0; i<V-1; i++)
                           {
                            id_pathShort[j][i]=id_path[id_Sorted[j]][i];
                            if (id_pathShort[j][i]) 
                             cout  << id_pathShort[j][i] << " ";
                           }
                             cout << "Number of hops_short = " << id_hops[id_Sorted[j]] << endl;
                   }
}
	// Driver program
	int main()
	{
		// Create a graph given in the above diagram
		Graph g(7);
			g.addEdge(1, 2);
			g.addEdge(2, 1);
			g.addEdge(1, 6);
			g.addEdge(6, 1);
			g.addEdge(2, 6);
			g.addEdge(6, 2);
			g.addEdge(2, 3);
			g.addEdge(3, 2);
			g.addEdge(3, 4);
			g.addEdge(4, 3);
			g.addEdge(3, 5);
			g.addEdge(5, 3);
			g.addEdge(4, 5);
			g.addEdge(5, 4);
			g.addEdge(5, 6);
			g.addEdge(6, 5);
		                        
		for (int k=0;k<=2; k++)
			{ int sources[k]={1,2,4,5};
			  int destinations[k]={3,4,5,1};
			  int s= sources[k];
			  int d= destinations[k];
                         
		 if( true){
		cout << "Following are all different paths from " << s
                    << " to " << d << endl;
		g.printAllPaths(s, d);
               }
	    };
	   return 0;
	}

---