基于数据结构知识求解两个动物之间通信最少翻译问题

摘  要

据美国动物分类学家欧内斯特•迈尔推算，世界上有超过一百万种动物，各 种动物有自己的语言。假设动物A可以与动物B进行通信（通信是双向的），但 它不能与动物C通信，动物C只能与动物B通信，所以动物 A、C 之间通信需要 动物 B 来当翻译。

通过C++语言基础分析和数据结构初步了解,我们使用C++语言，利用C++和数据结构的结合使用, 让我们在短时间内建立起对数据结构的进一步认识。 然后，形成正确的对算法和优有个的理解观念。

关键词：动物通信   C++  数据结构

第一章  绪  论

1.1 课设主要研究问题

假设动物A可以与动物B进行通信（通信是双向的），但 它不能与动物C通信，动物C只能与动物B通信，所以动物 A、C 之间通信需要 动物 B 来当翻译

1.2 课设应用的理论知识

1.2.1

邻接矩阵（Adjacency Matrix）是表示顶点之间相邻关系的矩阵。设G=(V,E)是一个图，其中V={v1,v2,…,vn}。G的邻接矩阵是一个具有下列性质的n阶方阵：

①对无向图而言，邻接矩阵一定是对称的，而且主对角线一定为零（在此仅讨论无向简单图），副对角线不一定为0，有向图则不一定如此。

②在无向图中，任一顶点i的度为第i列（或第i行）所有非零元素的个数，在有向图中顶点i的出度为第i行所有非零元素的个数，而入度为第i列所有非零元素的个数。

③用邻接矩阵法表示图共需要n^2个空间，由于无向图的邻接矩阵一定具有对称关系，所以扣除对角线为零外，仅需要存储上三角形或下三角形的数据即可，因此仅需要n（n-1）/2个空间。

图的深度优先搜索(Depth First Search) ，简称DFS。

1、深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点。可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。

2、该访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。

3、深度优先搜索是一个递归的过程。

第二章  课设实现过程

2.1 问题分析

求两点之间是否到达，如果到达则返回两点之间最短路径距离。采用方法图的邻接矩阵 构建图 图的深度遍历寻找最短路径

程序代码

#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;
	int i,j;
    cin >> n >> m;
    bool** graph = new bool* [n];       //建立n行n列的二维数组graph，用于记录动物间的通信关系所组成的图
    for ( i = 0; i < n; i++)
    {
        graph[i] = new bool[n];
    }
    for (i ; i < n; i++)     //初始化二维数组graph
    {
        for ( j =0; j < n; j++)
        {
            graph[i][j] = 0;
        }
    }

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