最少翻译者

广度优先搜索动物之间的通信关系所组成的图，当搜索到某个顶点时，把它的顶点号和目前搜索到的与原点的距离记录下来，作为一个节点加入到队列当中。然后从队头取出一个结点，如果该节点是搜索的目标顶点，且得到的路径比原来得到的最短路径还要短时，则把记录到的最短路径设为该值。直到队列为空。如果得到的最短路径为0或者1，则最少翻译者数量为0，其他情况的最少翻译者数量为最短路径减一。

#include <iostream>
using namespace std;

struct Node     //记录在搜索每一个顶点时的顶点号和离原点的距离
{
    int num;
    int length;
};

struct Queue_node       //队列的结点
{
    Node item;
    Queue_node* next;
};

struct Queue        //表示一个队列，包含头指针和尾指针
{
    Queue_node* front, * rear;
};

bool is_queue_empty(Queue* Q)       //判断队列Q是否为空，如果是则返回true，否则返回false
{
    if (Q->front == NULL || Q->rear == NULL)
        return true;
    else
        return false;
}

void enQueue(Queue *&Q, Node item)      //把item加到队列Q的队尾
{
    Queue_node* p = new Queue_node;
    p->item = item;
    p->next = NULL;
    if (is_queue_empty(Q))
    {
        Q->front = Q->rear = p;
        Q->rear = p;
    }
    else
    {
        Q->rear->next = p;
        Q->rear = p;
    }
}

bool deQueue(Queue *&Q, Node &item)     //移出队头元素，并将其赋给item
{
    if (is_queue_empty(Q))
        return false;
    Queue_node* p = Q->front;
    if (Q->front == Q->rear)
        Q->front = Q->rear = NULL;
    else
    {
        Q->front = Q->front->next;
    }
    item = p->item;
    delete p;
    return true;

}

void init_queue(Queue*& Q)      //初始化队列Q
{
    Q = new Queue;
    Q->front = Q->rear = NULL;
}

int bfs(bool** graph, int n, int animal_1, int animal_2)    //深度优先搜索查找结点号分别为animal_1和animal_2的结点的中间结点个数
{
    int best = 999;         //记录目前所得到的最短路径长度
    Queue* Q = NULL;
    init_queue(Q);
    Node e, item;
    e.num = animal_1;
    e.length = 0;
    enQueue(Q, e);
    while (!is_queue_empty(Q))
    {
        deQueue(Q, item);
        if (item.length > best || (item.num != animal_2 && item.length == best))        //如果正在遍历的结点离原点超过best，或者距离等于best但它的结点号不等于animal，则舍弃
            continue;
        else if (item.num == animal_2 && item.length < best)    //如果遍历到了结点animal_2并且其记录的与原点的距离小于best，则把best设为该值
        {
            best = item.length;
            continue;
        }
        for (int i = 0; i < n; i++)     //寻找邻接结点
        {
            if (graph[item.num][i] == 1 && i != animal_1)       //如果邻接结点不是原结点，则入队
            {
                e.num = i;
                e.length = item.length + 1;
                enQueue(Q, e);
            }
        }
    }
    if (best == 0 || best == 1)     //如果最短路径等于0或者1，则中间结点个数为0
        return 0;
    else if (best < 999)        //其他情况的中间结点个数为最短路径减一
        return best - 1;
    else                //无路径
        return -1;
}

int main(void)
{
    int n, m, k, animal_1, animal_2, result[20], a, b;
    cin >> n >> m;
    bool** graph = new bool* [n];       //建立n行n列的二维数组graph，用于记录动物间的通信关系所组成的图
    for (int i = 0; i < n; i++)
    {
        graph[i] = new bool[n];
    }
    for (int i = 0; i < n; i++)     //初始化二维数组graph
    {
        for (int j = 0; j < n; j++)
        {
            graph[i][j] = 0;
        }
    }
    for (int i = 0; i < m; i++)     //输入通信关系
    {
        cin >> animal_1 >> animal_2;
        graph[animal_1][animal_2] = 1;
        graph[animal_2][animal_1] = 1;
    }

    cin >> k;
    for (int i = 0; i < k; i++)     //对输入的两个动物序号计算其最少中间翻译者个数，并把结果保存到数组result[]
    {
        cin >> a >> b;
        result[i] = bfs(graph, n, a, b);
    }
    for (int i = 0; i < k; i++)     //输出结果
        cout << result[i] << endl;
    
    return 0;
}