哈利·波特的考试

• 题目来源：

浙江大学在慕课网上开设的《数据结构》课，陈越老师、何钦铭老师主讲，课后作业的一道题。

• 题目描述

• 题目思路：

这个题目是求图中“每一对顶点之间的最短路径”,应用到的算法是Floyd算法。

• C语言实现：

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MaxVerterNum 101  //最大定点数设为100
#define INFINITY 65535  //无穷设为双字节无符号整数的最大值65535

typedef int WeightType;  //边的权值设为int类型
typedef char DataType;  //顶点存储的数据类型设置为字符类型
typedef int Vertex;  //用顶点下标表示顶点，为整型

struct GNode
{
    int Nv;  //顶点数
    int Ne;  //边数
    WeightType G[MaxVerterNum][MaxVerterNum];  //邻接矩阵
    DataType Data[MaxVerterNum][MaxVerterNum];  //存顶点的数据
    /*如果顶点无数据，此时Data[]可以不出现*/
};
//描述边的类型
struct ENode
{
    Vertex V1, V2;  //有向边<V1,V2>
    WeightType Weight;  //权重
};
//作用：初始化一个有VertexNum个顶点但没有边的图
struct GNode* CreateGraph(int VertexNum)
{
    Vertex V, W;
    struct GNode* Graph;
    Graph = (struct GNode*)malloc(sizeof(struct GNode));  //建立图
    Graph->Nv = VertexNum;
    Graph->Ne = 0;

    //初始化邻接矩阵
    for (V = 0; V < Graph->Nv; V++)
    {
        for (W = 0; W < Graph->Nv; W++)
        {
            Graph->G[V][W] = INFINITY;
        }
    }

    for (V = 0; V < Graph->Nv; V++)
    {
        for (W = 0; W < Graph->Nv; W++)
        {
            if (V == W)
            {
                Graph->G[V][W] = 0;  //对角线初始化为0
                break;
            }
        }
    }
    return Graph;
}

//作用：在图中插入边
void InsertEdge(struct GNode* Graph, struct ENode* E)
{
    插入边<V1,V2>
    Graph->G[E->V1][E->V2] = E->Weight;
    若是无向图，还需要插入<V2,V1>
    Graph->G[E->V2][E->V1] = E->Weight;

    插入边<V1,V2>
    //Graph->G[E->V1][E->V2] = 1;
    若是无向图，还需要插入<V2,V1>
    //Graph->G[E->V2][E->V1] = 1;
}
//作用：构建一个图，供主函数调用
struct GNode* BulidGraph()
{
    Vertex V;
    int NV;
    struct ENode* E;
    struct GNode* Graph;
    scanf("%d", &NV);  //读入顶点个数
    Graph = CreateGraph(NV);
    scanf("%d", &(Graph->Ne));  //读入边数

    if (Graph->Ne != 0)
    {
        E = (struct ENode*)malloc(sizeof(struct ENode));
        for (int i = 0; i < Graph->Ne; i++)
        {
            //如果权重不是整型，Weight的读入格式要改
            scanf("%d %d %d",&E->V1,&E->V2,&E->Weight);
            E->V1--;
            E->V2--;
            InsertEdge(Graph, E);
        }
    }

    如果顶点有数据的话，读入数据
    //for (V = 0;V < Graph->Nv;V++)
    //{
    //  scanf("%c",&(Graph->Data[V]));
    //}

    return Graph;
}

//作用：Floyd算法
//参数：struct GNode* Graph 图
//      WeightType D[][MaxVerterNum] 最短路径长度
//      Vertex path[][MaxVerterNum] 最短路径
bool Floyd(struct GNode* Graph,WeightType D[][MaxVerterNum],Vertex path[][MaxVerterNum])
{
    int i, j, k;

    for (i = 0;i < Graph->Nv;i++)
    {
        for (j = 0;j < Graph->Nv;j++)
        {
            D[i][j] = Graph->G[i][j];
            path[i][j] = -1;
        }
    }

    for (k = 0;k < Graph->Nv;k++)
    {
        for (i = 0; i < Graph->Nv; i++)
        {
            for (j = 0; j < Graph->Nv; j++)
            {
                if (D[i][k] + D[k][j] < D[i][j])
                {
                    D[i][j] = D[i][k] + D[k][j];
                    if (i == j && D[i][j] < 0)  //若发现负值圈
                    {
                        return false;
                    }
                    path[i][j] = k;
                }
            }
        }
    }
    return true;
}

int main()
{
    int result = INFINITY;
    int Animal = 0;
    struct GNode* Graph = BulidGraph();
    WeightType D[MaxVerterNum][MaxVerterNum];
    Vertex path[MaxVerterNum][MaxVerterNum];
    if (Floyd(Graph,D,path))
    {
        int temp = 0;
        for (int i = 0;i < Graph->Nv;i++)
        {
            for (int j = 0;j < Graph->Nv;j++)
            {
                if (D[i][j] == INFINITY)
                {
                    printf("0");
                    return 0;
                }
                if (D[i][j] > temp)
                {
                    temp = D[i][j];
                }
            }
            if (temp < result)
            {
                result = temp;
                Animal = i;
            }
            temp = 0;
        }
    }
    printf("%d %d\n",Animal + 1,result);
    // system("pause");
    return 0;
}

转载于:https://www.cnblogs.com/Manual-Linux/p/11383978.html