社交图中 2 个节点之间的连接程度

我试图找出社交图中 2 个实体之间的联系程度，其中

1
• 跳：1度
2
• 跳：2度
3
• 跳：3度等等。

顶点是实体，边是两个实体之间的友谊。给定这样的图形，我想分析图形并回答有关实体之间连接类型的查询。它可以是断开连接的图形。如果没有连接，它将返回 0。

它将输入作为-

Number_of_vertices Number_of_Edges
Edge 1
Edge 2
(So on.)

查询

输出

连接程度

例

Input
5 4
Abhs Krax   // Edge 1
Harry Idrina   // Edge 2
Harry Jigma   // Edge 3
Harry Krax // Edge 4
Abhs Jigma  // Query

输出

Degree : 3

我已经使用 BFS 找出 2 个节点之间的深度，但我的程序仅适用于 1 度。它无法测试队列的下一个后续成员，因此只能测试队列的第一个成员。我在代码中遗漏了什么？问题出在我无法追踪Connection()功能上。

#include <iostream>
#include <list>
#include <string>
using namespace std;
class Vertex // Each vertex of the graph is represented by the object of the Vertex class
{
    public:
        // Fields in every vertex node
        string name;  
        std::list<Vertex*> adjacencyList;
        bool status;
        int depth;
        // Constructor which initializes the node
        Vertex(string id)
        {
            name = id;
            adjacencyList = list<Vertex*>();
            status = false;
            depth =0;
        }
        // Function to add edges by pushing the vertices to its adjacency list
        void addEdge(Vertex *v) 
        {
            adjacencyList.push_back(v);
        }
};
class Graph{
    public:
            // Fields of the Graph node
        int N;
        std::list<Vertex> vertexList;
                // Functions to be implemented 
        int Connection(Vertex,Vertex);

        Graph(int n){  // Constructor
            N = n;
            vertexList = list<Vertex>();
        }
                /* This function first checks whether the vertex has been already added 
                to Vertex List of the Graph. If not found it would create the vertex 
            node and push the node into Vertex List. Then the edges are added by
            updating the adjacency list of respective vertices. */
        void addEdge(string to, string from ){
                if(find(to))
            {
                Vertex entity_1 = Vertex(to);   // New vertex node creation
                vertexList.push_back(entity_1); // Pushing to the Vertex List
            }
            if(find(from))
            {
                Vertex entity_2 = Vertex(from);  
                vertexList.push_back(entity_2);
            }
            Vertex *v1 = &(*(find_it(to)));
            Vertex *v2 = &(*(find_it(from)));
            v1->addEdge(v2); // Updating respective adjacency list
            v2->addEdge(v1);
        }
        // Function to check whether the vertex is already added in the Vertex List
        int find(string check)
        {    
            list<Vertex>::iterator it;
            it = find_it(check);
            if(it==vertexList.end())
                return 1;
            else 
                return 0;
        }
        // Function which returns pointer to a Vertex in the Vertex List
        list<Vertex>::iterator find_it(string check)
        {   
            list<Vertex>::iterator it;
            for (it = vertexList.begin(); it != vertexList.end(); it++)
                if((check.compare(it->name))==0)
                    break;
            return it;
        }
};

int main()
{   
    int numVertices,numEdges,i,result;
    string to,from,queryTo,queryFrom;
    cin>>numVertices>>numEdges;
    Graph G = Graph(numVertices); // Creating the Graph object
    for( i=0;i<numEdges;i++)
    {
        cin>>to>>from;
        G.addEdge(to,from);  // Adding Edges to Graph
    }
    cin>>queryTo>>queryFrom;
        // The function you have to write is called here where the address of  vertex
        // node is passed.

    result = G.Connection((*(G.find_it(queryTo))),(*(G.find_it(queryFrom))));
    if(!result)
       cout<<"No Connection";
    else
       cout<<"Degree : "<<result;

    return 0;
}

int Graph::Connection(Vertex v1,Vertex v2)
{ 
    // Mark all the vertices as not visited
    Vertex s=Vertex("xx");
    int i=0;
    //list<Vertex>::iterator it;
    Vertex *temp=&(*(vertexList.begin()));
    while(!temp)
       temp->status = false,++temp;
    // Create a queue for BFS
    list<Vertex> queue;
    // Mark the current node as visited and enqueue it
    v1.status=true;
    queue.push_back(v1);
    // it will be used to get all adjacent vertices of a vertex
    int depth;
    while (!queue.empty())
    {
        depth=0;
        // Dequeue a vertex from queue and print it
        s = queue.front();
        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
        temp=s.adjacencyList.front();   
        while(temp!=NULL)
        {
            ++depth;
            // If this adjacent node is the destination node, then return true
            if ((v2.name.compare(temp->name))==0)
            {
                v2.depth=depth;
                return v2.depth;
            }
            // Else, continue to do BFS
            if(temp->status==false)
                {
                    temp->status = true;
                    queue.push_back(*temp);
                }
            ++temp;
         }
    }
    return 0;
}