принята

#include <iostream>
#include <queue>

struct edge
{
    int a;
    int b;
    int c;
};

struct adjacent_vertex
{
    int c;
    int b;
};

struct vertex
{
    bool visited = false;
    std::vector<struct adjacent_vertex> adj_list;
    int count_edges = 0;
};

void addEdge(int i, int j, int c, std::vector<vertex>& vertexes)
{
    adjacent_vertex buff;

    buff.b = j;
    buff.c = c;

    vertexes[i].adj_list.push_back(buff);

    buff.b = i;
    vertexes[j].adj_list.push_back(buff);

    vertexes[i].count_edges++;
    vertexes[j].count_edges++;
}


struct Compare
{
    bool operator()(edge& o1, edge& o2) const
    {
        return o1.c > o2.c;
    }
};

int main()
{
    std::priority_queue<struct edge, std::vector<struct edge>, Compare> heap;

    int n, m;
    std::cin >> n >> m;

    int a, b, c;
    std::vector<struct vertex> vertexes(n);
    struct edge EDG2;

    for (int i = 0; i < m; ++i)
    {
        std::cin >> a >> b >> c;

        addEdge(a - 1, b - 1, c, vertexes);

        if (a == 1 | b == 1)
        {
            EDG2.a = a - 1;
            EDG2.b = b - 1;
            EDG2.c = c;
            heap.push(EDG2);
        }
    }

    vertexes[0].visited = true;
    struct edge EDG;
    int new_vertex;
    int max = 0;

    for (int i = 0; i < n - 1; ++i)
    {

        EDG = heap.top();

        while (vertexes[EDG.a].visited & vertexes[EDG.b].visited)
        {
            heap.pop();
            EDG = heap.top();
        }

        heap.pop();

        if (max < EDG.c)
            max = EDG.c;

        if (vertexes[EDG.a].visited)
        {
            new_vertex = EDG.b;
            vertexes[new_vertex].visited = true;
        }
        else
        {
            new_vertex = EDG.a;
            vertexes[new_vertex].visited = true;
        }


        for (int j = 0; j < vertexes[new_vertex].count_edges; ++j)
        {
            EDG.a = new_vertex;
            EDG.b = vertexes[new_vertex].adj_list[j].b;
            EDG.c = vertexes[new_vertex].adj_list[j].c;

            if (not vertexes[EDG.b].visited)
                heap.push(EDG);
        }
    }

    std::cout << max;

    return 0;
}