07-图4 哈利·波特的考试

最新推荐文章于 2025-04-29 17:03:13 发布

毛懒懒

最新推荐文章于 2025-04-29 17:03:13 发布

阅读量72

点赞数

文章标签：算法数据结构

本文链接：https://blog.youkuaiyun.com/m0_51445530/article/details/130119062

版权

问题

哈利·波特要考试了，他需要你的帮助。这门课学的是用魔咒将一种动物变成另一种动物的本事。例如将猫变成老鼠的魔咒是haha，将老鼠变成鱼的魔咒是hehe等等。反方向变化的魔咒就是简单地将原来的魔咒倒过来念，例如ahah可以将老鼠变成猫。另外，如果想把猫变成鱼，可以通过念一个直接魔咒lalala，也可以将猫变老鼠、老鼠变鱼的魔咒连起来念：hahahehe。

现在哈利·波特的手里有一本教材，里面列出了所有的变形魔咒和能变的动物。老师允许他自己带一只动物去考场，要考察他把这只动物变成任意一只指定动物的本事。于是他来问你：带什么动物去可以让最难变的那种动物（即该动物变为哈利·波特自己带去的动物所需要的魔咒最长）需要的魔咒最短？例如：如果只有猫、鼠、鱼，则显然哈利·波特应该带鼠去，因为鼠变成另外两种动物都只需要念4个字符；而如果带猫去，则至少需要念6个字符才能把猫变成鱼；同理，带鱼去也不是最好的选择。

输入格式:

输入说明：输入第1行给出两个正整数N (≤100)和M，其中N是考试涉及的动物总数，M是用于直接变形的魔咒条数。为简单起见，我们将动物按1~N编号。随后M行，每行给出了3个正整数，分别是两种动物的编号、以及它们之间变形需要的魔咒的长度(≤100)，数字之间用空格分隔。

输出格式:

输出哈利·波特应该带去考场的动物的编号、以及最长的变形魔咒的长度，中间以空格分隔。如果只带1只动物是不可能完成所有变形要求的，则输出0。如果有若干只动物都可以备选，则输出编号最小的那只。

输入样例:

输出样例:

4 70

解答

//
// Created by world on 2023/4/5.
//

#include <iostream>
#include <queue>
#include <stack>

namespace AdjacencyMatrix
{
    const int INFINITY = 65535;

    struct ENode
    {
        int V1, V2;
        int Weight;

        ENode(int u, int v) : V1(u), V2(v), Weight(1) {}

        ENode(int u, int v, int w) : V1(u), V2(v), Weight(w) {}
    };

    class Graph
    {
    public:
        int Nv;
        int Ne;
        int **G;
        int **Distance;
        int **Path;
        bool *Status;

        Graph(int n1, int n2, int const *a) : Nv(n1), Ne(n2)
        {
            Status = new bool[n1];
            G = new int *[n1];
            Distance = nullptr;
            Path = nullptr;
            for (int i = 0, j; i < n1; ++i)
            {
                Status[i] = false;
                G[i] = new int[n1];
                for (j = 0; j < n1; ++j)
                {
                    G[i][j] = INFINITY;
                }
            }
            for (int k = 0; k < 3 * n2; k += 3)
                insert(ENode{a[k], a[k + 1], a[k + 2]});
        }

        [[nodiscard]] bool isEdge(int u, int v) const
        {
            return G[u][v] < INFINITY;
        }

        void insert(const ENode &E) const
        {
            G[E.V1][E.V2] = E.Weight;
            G[E.V2][E.V1] = E.Weight;
        }

        void BreadthFirstSearch(int S) const
        {
            std::queue<int> q;
            Status[S] = true;
            std::cout << ' ' << S;
            q.push(S);
            while (!q.empty())
            {
                int u = q.front();
                q.pop();
                for (int v = 0; v < Nv; ++v)
                {
                    if (!Status[v] and isEdge(u, v))
                    {
                        Status[v] = true;
                        std::cout << ' ' << v;
                        q.push(v);
                    }
                }
            }
        }

        void DepthFirstSearch(int S) const
        {
            std::stack<int> s;
            Status[S] = true;
            std::cout << ' ' << S;
            s.push(S);
            while (!s.empty())
            {
                int u = s.top();
                int v = 0;
                for (; v < Nv; ++v)
                {
                    if (!Status[v] and isEdge(u, v))
                    {
                        Status[v] = true;
                        std::cout << ' ' << v;
                        s.push(v);
                        break;
                    }
                }
                if (v == Nv)
                    s.pop();
            }
        }

        void BFS() const
        {
            for (int u = 0; u < Nv; ++u)
            {
                if (!Status[u])
                {
                    std::cout << '{';
                    BreadthFirstSearch(u);
                    std::cout << " }\n";
                }
            }
            reset();
        }

        void DFS() const
        {
            for (int u = 0; u < Nv; ++u)
            {
                if (!Status[u])
                {
                    std::cout << '{';
                    DepthFirstSearch(u);
                    std::cout << " }\n";
                }
            }
            reset();
        }

        void reset() const
        {
            for (int i = 0; i < Nv; ++i)
            {
                Status[i] = false;
            }
        }

        bool Floyd()
        {
            Distance = new int *[Nv];
            Path = new int *[Nv];
            for (int i = 0, j; i < Nv; ++i)
            {
                Distance[i] = new int[Nv];
                Path[i] = new int[Nv];
                for (j = 0; j < Nv; ++j)
                {
                    if (i != j)
                        Distance[i][j] = G[i][j];
                    else
                        Distance[i][j] = 0;
                    Path[i][j] = -1;
                }
            }
            for (int k = 0; k < Nv; ++k)
                for (int i = 0; i < Nv; ++i)
                    for (int j = 0; j < Nv; ++j)
                        if (Distance[i][k] + Distance[k][j] < Distance[i][j])
                        {
                            Distance[i][j] = Distance[i][k] + Distance[k][j];
                            if (i == j && Distance[i][j] < 0) /* 若发现负值圈 */
                                return false;/* 不能正确解决，返回错误标记 */
                            Path[i][j] = k;
                        }
            return true;
        }

        void printGraph() const
        {
            for (int i = 0; i < Nv; ++i)
            {
                for (int j = 0; j < Nv; ++j)
                    std::cout << G[i][j] << ' ';
                std::cout << '\n';
            }
        }

        void printDis() const
        {
            for (int i = 0; i < Nv; ++i)
            {
                for (int j = 0; j < Nv; ++j)
                    std::cout << Distance[i][j] << ' ';
                std::cout << '\n';
            }
        }

        ~Graph()
        {
            delete[]Status;
            for (int i = 0; i < Nv; ++i)
            {
                delete[]G[i];
            }
            delete[]G;
            if (Distance or Path)
            {
                for (int i = 0; i < Nv; ++i)
                {
                    delete[]Distance[i];
                    delete[]Path[i];
                }
                delete[]Distance;
                delete[]Path;
            }
        }
    };
}

using namespace AdjacencyMatrix;

int main()
{
    int N, M;
    std::cin >> N >> M;
    int *a = new int[3 * M];
    for (int i = 0; i < 3 * M; i += 3)
    {
        int u, v, w;
        std::cin >> u >> v >> w;
        a[i] = u - 1;
        a[i + 1] = v - 1;
        a[i + 2] = w;
    }
    Graph g(N, M, a);
    g.Floyd();
    int maxLocal, minGlobal = INFINITY;
    int number = 0;
    for(int i=0;i<N;++i)
    {
        maxLocal = -1;
        for(int j=0;j<N;++j)
        {
            maxLocal = std::max(maxLocal, g.Distance[i][j]);
        }
        if(maxLocal == INFINITY)
            break;
        else if(minGlobal > maxLocal)
        {
            minGlobal =  maxLocal;
            number = i;
        }     
    }
    if(maxLocal != INFINITY)
        std::cout<<number+1<<' '<<minGlobal<<'\n';
    else
        std::cout<<'0'<<'\n';
    delete[]a;
    return 0;
}