Add graph shortest path

Author: adamant-pwn

cp-algo/data_structures/stack_union.hpp

@@ -5,11 +5,11 @@
 namespace cp_algo::data_structures {
     template<class datatype>
     struct stack_union {
-        stack_union(int n = 0): n(n), head(n), next(1), data(1) {}
+        stack_union(int n = 0): head(n), next(1), data(1) {}
 
         void push(int v, datatype const& vdata) {
             next.push_back(head[v]);
-            head[v] = size(next) - 1;
+            head[v] = std::size(next) - 1;
             data.push_back(vdata);
         }
         template<typename... Args>
@@ -19,7 +19,9 @@ namespace cp_algo::data_structures {
             data.emplace_back(std::forward<Args...>(vdata...));
         }
 
-        int n;
+        size_t size() const {return std::size(head);}
+        size_t nodes() const {return std::size(data);}
+
         std::vector<int> head, next;
         std::vector<datatype> data;
     };

cp-algo/graph/base.hpp

@@ -5,14 +5,16 @@
 #include <ranges>
 #include <vector>
 namespace cp_algo::graph {
+    using node_index = int;
+    using edge_index = int;
     struct edge_base {
-        int to;
+        node_index to;
 
         edge_base() {}
-        edge_base(int v): to(v) {}
+        edge_base(node_index v): to(v) {}
 
-        static auto read(int v0 = 0) {
-            int u, v;
+        static auto read(node_index v0 = 0) {
+            node_index u, v;
             std::cin >> u >> v;
             return std::pair{u - v0, edge_base(v - v0)};
         }
@@ -21,54 +23,74 @@ namespace cp_algo::graph {
             return {from};
         }
     };
-    template<typename edge_info>
-    concept edge_type = std::is_base_of_v<edge_base, edge_info>;
+
+    struct weighted_edge: edge_base {
+        int64_t w;
+
+        weighted_edge() {}
+        weighted_edge(node_index v, int64_t w): edge_base(v), w(w) {}
+
+        static auto read(node_index v0 = 0) {
+            node_index u, v;
+            int64_t w;
+            std::cin >> u >> v >> w;
+            return std::pair{u - v0, weighted_edge{v - v0, w}};
+        }
+
+        weighted_edge backedge(node_index from) const {
+            return {from, w};
+        }
+    };
+
+    template<typename edge>
+    concept edge_type = std::is_base_of_v<edge_base, edge>;
+    template<typename edge>
+    concept weighted_edge_type = std::is_base_of_v<weighted_edge, edge>;
 
     enum type {directed = 0, undirected = 1};
-    template<type _undirected, edge_type edge_info = edge_base>
+    template<type _undirected, edge_type edge_t = edge_base>
     struct graph {
         static constexpr bool undirected = _undirected;
-        graph(int n, int v0 = 0): _n(n), _m(0), v0(v0), _adj(n) {}
+        graph(int n, int v0 = 0): v0(v0), _adj(n) {}
 
-        void add_edge(int u, edge_info e) {
-            _m++;
+        void add_edge(node_index u, edge_t e) {
             _adj.push(u, size(edges));
             edges.push_back(e);
             if constexpr (undirected) {
                 _adj.push(e.to, size(edges));
             }
             edges.push_back(e.backedge(u));
         }
-        void read_edges(int m) {
-            for(int i = 0; i < m; i++) {
-                auto [u, e] = edge_info::read(v0);
+        void read_edges(node_index m) {
+            for(edge_index i = 0; i < m; i++) {
+                auto [u, e] = edge_t::read(v0);
                 add_edge(u, e);
             }
         }
-        void call_adjacent(int v, auto &&callback, auto &&terminate) const {
+        void call_adjacent(node_index v, auto &&callback, auto &&terminate) const {
             for(int sv = _adj.head[v]; sv && !terminate(); sv = _adj.next[sv]) {
                 callback(_adj.data[sv]);
             }
         }
-        void call_adjacent(int v, auto &&callback) const {
+        void call_adjacent(node_index v, auto &&callback) const {
             call_adjacent(v, callback, [](){return false;});
         }
         void call_edges(auto &&callback) const {
-            for(int v: nodes_view()) {
-                call_adjacent(v, [&](int e) {callback(v, e);});
+            for(node_index v: nodes_view()) {
+                call_adjacent(v, [&](edge_index e) {callback(v, e);});
             }
         }
         auto nodes_view() const {
-            return std::views::iota(0, _n);
+            return std::views::iota(0, n());
         }
         auto const& incidence_lists() const {return _adj;}
-        auto const& edge(int e) const {return edges[e];}
-        int n() const {return _n;}
-        int m() const {return _m;}
+        edge_t const& edge(edge_index e) const {return edges[e];}
+        size_t n() const {return _adj.size();}
+        size_t m() const {return size(edges) / 2;}
     private:
-        int _n, _m, v0;
-        std::vector<edge_info> edges;
-        data_structures::stack_union<int> _adj;
+        node_index v0;
+        std::vector<edge_t> edges;
+        data_structures::stack_union<edge_index> _adj;
     };
 }
 #endif // CP_ALGO_GRAPH_BASE_HPP

cp-algo/graph/shortest_path.hpp

@@ -0,0 +1,49 @@
+#ifndef CP_ALGO_GRAPH_SHORTEST_PATH_HPP
+#define CP_ALGO_GRAPH_SHORTEST_PATH_HPP
+#include "base.hpp"
+#include <algorithm>
+#include <queue>
+namespace cp_algo::graph {
+    template<type _, weighted_edge_type edge_t>
+    auto dijkstra(graph<_, edge_t> const& g, int s) {
+        static constexpr uint64_t inf = 1e18;
+        std::vector<uint64_t> dist(g.n(), inf);
+        std::vector<std::pair<node_index, edge_index>> pre(g.n());
+        using que_t = std::pair<uint64_t, node_index>;
+        std::priority_queue<que_t, std::vector<que_t>, std::greater<>> que;
+        dist[s] = 0;
+        que.push({0, s});
+        while(!empty(que)) {
+            auto [dv, v] = que.top();
+            que.pop();
+            if(dv != dist[v]) {
+                continue;
+            }
+            g.call_adjacent(v, [&](auto e) {
+                node_index u = g.edge(e).to;
+                auto w = g.edge(e).w;
+                if(dist[v] + w < dist[u]) {
+                    pre[u] = {v, e};
+                    dist[u] = dist[v] + w;
+                    que.push({dist[u], u});
+                }
+            });
+        }
+        return std::pair{dist, pre};
+    }
+
+    template<type _, weighted_edge_type edge_t>
+    auto shortest_path(graph<_, edge_t> const& g, int s, int t) {
+        static constexpr uint64_t inf = 1e18;
+        auto [dist, pre] = dijkstra(g, s);
+        std::vector<std::pair<node_index, edge_index>> path;
+        int64_t d = dist[t] == inf ? -1 : dist[t];
+        while(d != -1 && t != s) {
+            path.push_back(pre[t]);
+            t = pre[t].first;
+        }
+        std::ranges::reverse(path);
+        return std::pair{d, path};
+    }
+}
+#endif // CP_ALGO_GRAPH_SHORTEST_PATH_HPP

verify/graph/shortest_path.test.cpp

@@ -0,0 +1,35 @@
+// @brief Shortest Path
+#define PROBLEM "https://judge.yosupo.jp/problem/shortest_path"
+#pragma GCC optimize("Ofast,unroll-loops")
+#include "cp-algo/graph/shortest_path.hpp"
+#include <bits/stdc++.h>
+
+using namespace std;
+using namespace cp_algo::graph;
+
+void solve() {
+    int n, m, s, t;
+    cin >> n >> m >> s >> t;
+    graph<directed, weighted_edge> g(n);
+    g.read_edges(m);
+    auto [X, Y] = shortest_path(g, s, t);
+    if(X == -1) {
+        cout << X << "\n";
+    } else {
+        cout << X << ' ' << size(Y) << "\n";
+        for(auto [u, e]: Y) {
+            cout << u << ' ' << g.edge(e).to << "\n";
+        }
+    }
+}
+
+signed main() {
+    //freopen("input.txt", "r", stdin);
+    ios::sync_with_stdio(0);
+    cin.tie(0);
+    int t = 1;
+    //cin >> t;
+    while(t--) {
+        solve();
+    }
+}