【数据结构与算法暑期实习】PTA 网红点打卡攻略

一、题目

一个旅游景点，如果被带火了的话，就被称为“网红点”。大家来网红点游玩，俗称“打卡”。在各个网红点打卡的快（省）乐（钱）方法称为“攻略”。你的任务就是从一大堆攻略中，找出那个能在每个网红点打卡仅一次、并且路上花费最少的攻略。

输入格式：
第一行给出两个正整数：网红点的个数 N（1<N≤200）和网红点之间通路的条数 M。随后 M 行，每行给出有通路的两个网红点、以及这条路上的旅行花费（为正整数），格式为“网红点1 网红点2 费用”，其中网红点从 1 到 N 编号；同时也给出你家到某些网红点的花费，格式相同，其中你家的编号固定为 0。

再下一行给出一个正整数 K，是待检验的攻略的数量。随后 K 行，每行给出一条待检攻略，格式为：n V​1 V2⋯ Vn。其中 n(≤200) 是攻略中的网红点数，V​i是路径上的网红点编号。这里假设你从家里出发，从 V​1开始打卡，最后从 Vn 回家。

输出格式：
在第一行输出满足要求的攻略的个数。在第二行中，首先输出那个能在每个网红点打卡仅一次、并且路上花费最少的攻略的序号（从 1 开始），然后输出这个攻略的总路费，其间以一个空格分隔。如果这样的攻略不唯一，则输出序号最小的那个。题目保证至少存在一个有效攻略，并且总路费不超过 10^9。

输入样例：
6 13
0 5 2
6 2 2
6 0 1
3 4 2
1 5 2
2 5 1
3 1 1
4 1 2
1 6 1
6 3 2
1 2 1
4 5 3
2 0 2
7
6 5 1 4 3 6 2
6 5 2 1 6 3 4
8 6 2 1 6 3 4 5 2
3 2 1 5
6 6 1 3 4 5 2
7 6 2 1 3 4 5 2
6 5 2 1 4 3 6

输出样例：
3
5 11

样例说明：
第 2、3、4、6 条都不满足攻略的基本要求，即不能做到从家里出发，在每个网红点打卡仅一次，且能回到家里。所以满足条件的攻略有 3 条。

第 1 条攻略的总路费是：(0->5) 2 + (5->1) 2 + (1->4) 2 + (4->3) 2 + (3->6) 2 + (6->2) 2 + (2->0) 2 = 14；

第 5 条攻略的总路费同理可算得：1 + 1 + 1 + 2 + 3 + 1 + 2 = 11，是一条更省钱的攻略；

第 7 条攻略的总路费同理可算得：2 + 1 + 1 + 2 + 2 + 2 + 1 = 11，与第 5 条花费相同，但序号较大，所以不输出。

二、思路

本题考查的是图数据结构，存储方式采用邻接矩阵是比较合适的。通过本题我主要学习到了邻接矩阵的定义、构建和使用方法。后面对攻略是否可行的判断以及费用的计算，理清逻辑一步步来就行，还是比较清晰的。

三、代码

数据结构定义（图，采用邻接矩阵存储）

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
using namespace std;

#define MaxVertexNum 200	/* 最大顶点数设为200 */
typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
typedef int WeightType;		/* 边的权值设为整型 */

/* 边的定义 */
typedef struct ENode* PtrToENode;
struct ENode {
    Vertex v1, v2;      /* 有向边<V1, V2> */
    WeightType weight;  /* 权重 */
};
typedef PtrToENode Edge;

/* 图结点的定义 */
typedef struct GNode* PtrToGNode;
struct GNode {
    int Nv;  /* 顶点数 */
    int Ne;  /* 边数   */
    WeightType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
};
typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 */


/* 初始化一个有VertexNum个顶点但没有边的图 */
MGraph CreateGraph(int VertexNum)
{
    Vertex v, u;
    MGraph Graph;

    Graph = (MGraph)malloc(sizeof(struct GNode)); /* 建立图 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* 初始化邻接矩阵 */
    /* 注意：这里默认顶点编号从0开始，到(Graph->Nv - 1) */
    for (v = 0; v < Graph->Nv; v++) {
        for (u = 0; u < Graph->Nv; u++) {
            Graph->G[v][u] = 0;
        }
    }
    return Graph;
}


/* 插入边 <V1, V2> */
void InsertEdge(MGraph Graph, Edge E)
{
    Graph->G[E->v1][E->v2] = E->weight;
    /* 若是无向图，还要插入边<V2, V1> */
    Graph->G[E->v2][E->v1] = E->weight;
}


MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    int Nv, i;

    scanf_s("%d", &Nv);   /* 读入顶点个数、边的个数 */
    Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */
    scanf_s("%d", &(Graph->Ne));   /* 读入边数 */

    if (Graph->Ne != 0) { /* 如果有边 */
        E = (Edge)malloc(sizeof(struct ENode)); /* 建立边结点 */
        /* 读入边，格式为"起点 终点 权重"，插入邻接矩阵 */
        for (i = 0; i < Graph->Ne; i++) {
            scanf_s("%d %d %d", &E->v1, &E->v2, &E->weight);
            /* 注意：如果权重不是整型，Weight的读入格式要改 */
            InsertEdge(Graph, E);
        }
    }
    return Graph;
}

主程序

int cost, res;
int path[205], tag[205];

int main() {
    MGraph map = BuildGraph(); //建立图（邻接矩阵），输入点数n、边数m，并按“点1，点2，费用”格式向矩阵中输入数据；

    int l = 0, k, t, cnt = 0;
    cost = 1e9 + 1;//设置一个费用初始值（最大+1），主要是为了方便后面与第一次攻略的费用比较
    scanf_s("%d", &k); //输入攻略个数
    while (k--)
    {
        cnt++;
        scanf_s("%d", &t);//输入每个攻略的打卡点个数
        int cost_real = 0;
        memset(tag, 0, sizeof(tag));
        for (int i = 1; i <= t; i++)
        {
            scanf_s("%d", &path[i]); //输入每个攻略的路径（打卡点顺序）
            tag[path[i]]++;  //tag用来标记已打卡过的点（或者理解为标记每个点的打卡次数，0、1、2等）
        }
        path[t + 1] = 0;  //定义终点，即家始终标记为0

        //打卡点不全的攻略，踢出不予考虑
        if (t != map->Nv) continue;
        //判断是否重复打卡，如有，踢出不予考虑
        for (int i = 1; i <= map->Nv; i++)
            if (tag[i] != 1) t--;
        if (t != map->Nv) continue;
        //无未打卡点，无重复打卡点，接下来判断打卡路径是否可行（相邻两点之间是否存在通路）
        for (int i = 0; i <= t; i++)
        {
            if (map->G[path[i]][path[i + 1]] == 0)
            {
                t--;
                break;
            }
            //若打卡路径没有问题，则累加计算总费用
            cost_real = cost_real + map->G[path[i]][path[i + 1]];
        }
        if (t != map->Nv) continue;
        l++; //记录可行的路径（攻略）数
        if (cost > cost_real)
        {   /*比较相邻两可行攻略的费用，取最小费用和其对应的攻略序号*/
            cost = cost_real;
            res = cnt;
        }
    }
    printf("%d\n%d %d\n", l, res, cost);
    return 0;
}