Без принтов, работает

#include <iostream>
#include <queue>

struct edge
{
    int idx;
    int a;
    int b;
    int cost;
};

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

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

    buff.idx = j;
    buff.cost = cost;
    buff.a = i;
    buff.b = j;

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

    buff.idx = 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.cost > o2.cost;
    }
};

void showpq(std::priority_queue<struct edge, std::vector<struct edge>, Compare> gq)
{
    std::priority_queue<struct edge, std::vector<struct edge>, Compare> g = gq;
    while (!g.empty())
    {
        std::cout << '\t' << g.top().cost;
        g.pop();
    }
    std::cout << '\n';
}

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.cost = 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();

        heap.pop();

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

        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 = vertexes[new_vertex].adj_list[j];

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

    std::cout << max;

    return 0;
}