TaskA

#include <iostream>
#include <vector>
#include <set>
#include <algorithm>

using namespace std;

class Edge
{
public:
    int A;
    int B;
    int W;
};

using Matrix = vector<vector<int>>;

struct Vertex {
    int maxDistEstim = INT32_MAX;
    int index;
};

struct Comparator {
    bool operator()(const Vertex* first, const Vertex* second)
    {
        if (first->maxDistEstim == second->maxDistEstim)
            return first->index < second->index;
        else
            return first->maxDistEstim < second->maxDistEstim;
    }
};

void solve(int N, int M, vector<Edge>& edges, vector<int>& result)
{
    vector<Vertex> vertices(N);
    for (int i = 0; i < vertices.size(); ++i)
        vertices[i].index = i;
    vertices[0].maxDistEstim = 0;

    Matrix relations(N);
    for (vector<int>& vec : relations)
        vec = vector<int>(N);
    for (const Edge& edge : edges)
        relations[edge.A][edge.B] = edge.W;

    auto compare = [](const Vertex* first, const Vertex* second) -> bool {
        if (first->maxDistEstim == second->maxDistEstim)
            return first->index < second->index;
        else
            return first->maxDistEstim < second->maxDistEstim;
    };

    set<Vertex*, bool (*)(const Vertex* first, const Vertex* second)> set(compare);
    for (Vertex& vertex : vertices)
        set.insert(&vertex);
    while (!set.empty())
    {
        Vertex* v = *set.begin();
        set.erase(v);
        for (int j = 0; j < relations[v->index].size(); ++j)
        {
            if (relations[v->index][j] != 0 && v->maxDistEstim + relations[v->index][j] < vertices[j].maxDistEstim)
            {
                set.erase(&vertices[j]);
                vertices[j].maxDistEstim = v->maxDistEstim + relations[v->index][j];
                set.insert(&vertices[j]);
            }
        }
    }
    for (int i = 1; i < vertices.size(); ++i)
        result.push_back(vertices[i].maxDistEstim);
}

int main()
{
    int N, M;
    cin >> N;
    cin >> M;
    vector<Edge> edges;
    for (int i = 0; i < M; i++)
    {
        Edge e;
        cin >> e.A>> e.W >> e.B;
        e.A -= 1;
        e.B -= 1;
        edges.push_back(e);
    }

    vector<int> result;

    solve(N, M, edges, result);

    for (int i = 0; i < result.size(); i++)
        cout << result[i] << " ";

    return 0;
}