A (virgin input)

#include <vector>
#include <iostream>

using namespace std;

struct Vertex;

struct Edge{
    Vertex* neighbour;
    int weight;
};

static const size_t INF = 1 << 30;


struct Vertex{
    bool visited = false;
    size_t distance = INF;

    void add_edge(Vertex* neighbour, int weight){
        out_edges_.push_back({neighbour, weight});
    }

    vector<Edge> get_neighbours(){
        return out_edges_;
    };


private:
    vector<Edge> out_edges_;
};

class WeightedGraph{
public:
    explicit WeightedGraph(int v) : graph_(v+1), v_amount_(v){}

    void add_edge(int a, int b, int weight){
        graph_[a+1].add_edge(&graph_[b+1], weight);
    }

    size_t get_path_length(int start, int finish){
        graph_[start].distance = 0;
        graph_[start].visited = true;
        relaxation(start);

        for (int step = 0; step < v_amount_-1; ++step){
            auto mn = find_minimum_distance_vertex();
            relaxation(mn);
        }

        auto result = graph_[finish].distance;
        return result;
    }

private:
    int find_minimum_distance_vertex(){
        size_t mn = INF;
        int result = -1;
        for (int i = 1; i < v_amount_+1; ++i){
            if (!graph_[i].visited && graph_[i].distance < mn){
                mn = graph_[i].distance;
                result = i;
            }
        }
        return result;
    }

    void relaxation(int v_ind){
        auto v = &graph_[v_ind];
        v->visited = true;
        for (auto [neighbour, weight] : v->get_neighbours()){
            if (neighbour->distance > v->distance + weight){
                neighbour->distance = v->distance + weight;
            }
        }
    }

    vector<Vertex> graph_;
    int v_amount_;
};


int main(){
    int v_amount, start, finish;
    cin >> v_amount >> start >> finish;

    WeightedGraph graph(v_amount);

    for (int v = 0; v < v_amount; ++v){
        for (int neighbour = 0; neighbour < v_amount; ++neighbour){
            int weight = 0;
            cin >> weight;

            if (neighbour == v){
                continue;
            }
            if (weight != -1){
                graph.add_edge(v, neighbour, weight);
            }
        }
    }

    size_t path_length = graph.get_path_length(start, finish);

    if (path_length == INF){
        cout << -1;
        return 0;
    }
    cout << path_length;
}