Shared code

#include <iostream>
#include <vector>
#include <unordered_map>
#include <queue>
#include <climits>
#include <algorithm>

// #include "debugging.h"

using std::cout;
using std::endl;
using std::vector;

constexpr int MOD = 1e9 + 7;

// https://cses.fi/problemset/task/1202 (input ommitted due to length)
int main() {
    int city_num;
    int flight_num;
    std::cin >> city_num >> flight_num;
    vector<vector<std::pair<int, int>>> neighbors(city_num);
    for (int f = 0; f < flight_num; f++) {
        int from;
        int to;
        int cost;
        std::cin >> from >> to >> cost;
        neighbors[--from].push_back({--to, cost});
    }

    vector<long long> min_cost(neighbors.size(), LLONG_MAX);
    vector<long long> shortest_num(city_num);
    vector<int> least_flights(city_num);
    vector<int> most_flights(city_num);
    vector<bool> visited(city_num);
    min_cost[0] = 0;
    shortest_num[0] = 1;

    auto cmp = [&] (const int& a, const int& b) { return min_cost[a] > min_cost[b]; }; 
    std::priority_queue<int, vector<int>, decltype(cmp)> frontier(cmp);
    frontier.push(0);
    while (!frontier.empty()) {
        int curr = frontier.top();
        frontier.pop();
        long long curr_cost = min_cost[curr];

        if (visited[curr]) {
            continue;
        }
        visited[curr] = true;

        for (auto [n, nc] : neighbors[curr]) {
            if (curr_cost + nc == min_cost[n]) {
                shortest_num[n] = (shortest_num[n] + shortest_num[curr]) % MOD;
                least_flights[n] = std::min(least_flights[n], least_flights[curr] + 1);
                most_flights[n] = std::max(most_flights[n], most_flights[curr] + 1);

                frontier.push(n);
            } else if (curr_cost + nc < min_cost[n]) {
                shortest_num[n] = shortest_num[curr];
                least_flights[n] = least_flights[curr] + 1;
                most_flights[n] = most_flights[curr] + 1;

                min_cost[n] = curr_cost + nc;
                frontier.push(n);
            }
        }
    }
    cout << min_cost[city_num - 1] << ' '
         << shortest_num[city_num - 1] << ' '
         << least_flights[city_num - 1] << ' '
         << most_flights[city_num - 1] << endl;
}