Merge branch 'main' into monotone-minima

.verify-helper/timestamps.remote.json

@@ -8,6 +8,7 @@
 "test/aoj-cgl-3-c.test.cpp": "2023-09-07 23:01:33 +0900",
 "test/aoj-cgl-4-a.test.cpp": "2023-09-07 23:01:33 +0900",
 "test/aoj-cgl-5-a.test.cpp": "2023-09-07 23:01:33 +0900",
+"test/aoj-dsl-1-b.test.cpp": "2024-05-07 01:35:46 +0900",
 "test/aoj-dsl-2-a.test.cpp": "2024-03-27 20:35:39 +0900",
 "test/aoj-dsl-2-a.test.py": "2023-09-07 14:26:13 +0900",
 "test/aoj-dsl-2-b.test.cpp": "2024-03-27 20:35:39 +0900",
@@ -19,7 +20,8 @@
 "test/aoj-grl-5-a.test.cpp": "2023-06-16 15:41:49 +0900",
 "test/aoj-grl-5-b.test.cpp": "2023-06-16 15:41:49 +0900",
 "test/aoj-itp1-1-a.binary-trie.test.cpp": "2024-04-10 15:58:54 +0900",
-"test/atcoder-abc177-f.1.test.cpp": "2024-04-17 23:17:39 +0900",
+"test/aoj-jag-summer-2971.test.cpp": "2024-05-07 01:35:46 +0900",
+"test/atcoder-abc177-f.1.test.cpp": "2024-03-26 22:46:46 +0900",
 "test/atcoder-abc177-f.2.test.cpp": "2024-03-26 22:46:46 +0900",
 "test/atcoder-abc185-f.test.cpp": "2024-03-27 20:35:39 +0900",
 "test/atcoder-abc254-f.test.cpp": "2024-03-27 20:35:39 +0900",

cpp/more_functional.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+/**
+ * @file more_functional.hpp
+ * @brief 関数オブジェクトを定義する
+ */
+
+namespace more_functional {
+template <typename S>
+struct Zero {
+    S operator()() const { return S(0); }
+};
+template <typename S>
+struct One {
+    S operator()() const { return S(1); }
+};
+template <typename S>
+struct None {
+    S operator()() const { return S{}; }
+};
+template <typename S>
+struct Div {
+    S operator()(const S& a) const { return S(1) / a; }
+};
+}  // namespace more_functional

cpp/potentialized-unionfind.hpp

@@ -0,0 +1,149 @@
+#pragma once
+
+/**
+ * @file potentialized-unionfind.hpp
+ * @brief ポテンシャル付きUnionFind
+ */
+#include <cassert>
+#include <functional>
+#include <stack>
+#include <utility>
+#include <vector>
+#include "more_functional.hpp"
+
+/**
+ * @brief ポテンシャル付きUnionFind
+ * @tparam S ポテンシャルの型
+ * @tparam Op Sの積のファンクタ
+ * @tparam E Sの単位元を返すファンクタ
+ * @tparam Inv Sの逆元を返すファンクタ
+ */
+template <typename S, class Op, class E, class Inv>
+class PotentializedUnionFind {
+   private:
+    int _n;
+    // 負ならサイズ、非負なら親
+    std::vector<int> parent_or_size;
+    // 重み
+    std::vector<S> diff_weight;
+
+    inline constexpr static auto op = Op();
+    inline constexpr static auto e = E();
+    inline constexpr static auto inv = Inv();
+
+   public:
+    PotentializedUnionFind() : _n{}, parent_or_size{}, diff_weight{} {}
+
+    /**
+     * @param n 要素数
+     */
+    explicit PotentializedUnionFind(int n) : _n(n), parent_or_size(n, -1), diff_weight(n, e()) {}
+
+    /**
+     * @brief 頂点aの属する連結成分の代表元
+     */
+    int leader(int a) {
+        assert(0 <= a && a < _n);
+        if (parent_or_size[a] < 0) return a;
+        std::stack<int> stk;
+        stk.push(a);
+        while (parent_or_size[stk.top()] >= 0) {
+            stk.push(parent_or_size[stk.top()]);
+        }
+        const int root = stk.top();
+        stk.pop();
+        stk.pop();
+        while (!stk.empty()) {
+            diff_weight[stk.top()] = op(diff_weight[parent_or_size[stk.top()]], diff_weight[stk.top()]);
+            parent_or_size[stk.top()] = root;
+            stk.pop();
+        }
+        return root;
+    }
+
+    /**
+     * @brief a のグループと b のグループを統合する
+     * @param w (b のポテンシャル) - (a のポテンシャル)
+     * @return 連結したものの代表元
+     */
+    int merge(int a, int b, S w) {
+        assert(0 <= a && a < _n);
+        assert(0 <= b && b < _n);
+        w = op(weight(a), w);
+        w = op(w, inv(weight(b)));
+        int x = leader(a), y = leader(b);
+        if (x == y) return x;
+        if (-parent_or_size[x] < -parent_or_size[y]) {
+            std::swap(x, y);
+            w = inv(w);
+        }
+        parent_or_size[x] += parent_or_size[y];
+        parent_or_size[y] = x;
+        diff_weight[y] = w;
+        return x;
+    }
+
+    /**
+     * @brief 頂点a,bが連結かどうか
+     */
+    bool same(int a, int b) {
+        assert(0 <= a && a < _n);
+        assert(0 <= b && b < _n);
+        return leader(a) == leader(b);
+    }
+
+    /**
+     * @brief (b のポテンシャル) - (a のポテンシャル)
+     * @remark デフォルトコンストラクタで作られる S について Inv が定義されているならば、a == b を許容
+     */
+    S diff(int a, int b) {
+        assert(same(a, b));
+        return op(inv(weight(a)), weight(b));
+    }
+
+    /**
+     * @brief 頂点aの属する連結成分のサイズ
+     */
+    int size(int a) {
+        assert(0 <= a && a < _n);
+        return -parent_or_size[leader(a)];
+    }
+
+    /**
+     * @brief グラフを連結成分に分け、その情報を返す
+     * @return 「一つの連結成分の頂点番号のリスト」のリスト
+     */
+    std::vector<std::vector<int>> groups() {
+        std::vector<int> leader_buf(_n), group_size(_n);
+        for (int i = 0; i < _n; i++) {
+            leader_buf[i] = leader(i);
+            group_size[leader_buf[i]]++;
+        }
+        std::vector<std::vector<int>> result(_n);
+        for (int i = 0; i < _n; i++) {
+            result[i].reserve(group_size[i]);
+        }
+        for (int i = 0; i < _n; i++) {
+            result[leader_buf[i]].push_back(i);
+        }
+        result.erase(std::remove_if(result.begin(), result.end(), [&](const std::vector<int>& v) { return v.empty(); }), result.end());
+        return result;
+    }
+
+   private:
+    S weight(int a) {
+        leader(a);
+        return diff_weight[a];
+    }
+};
+
+/**
+ * @tparam S 群の型
+ */
+template <typename S>
+using UnionFindPlus = PotentializedUnionFind<S, std::plus<S>, more_functional::None<S>, std::negate<S>>;
+/**
+ * @tparam S 群の型
+ */
+template <typename S>
+using UnionFindMul = PotentializedUnionFind<S, std::multiplies<S>, more_functional::One<S>, more_functional::Div<S>>;

test/aoj-dsl-1-b.test.cpp

@@ -0,0 +1,27 @@
+#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/problems/DSL_1_B"
+
+#include <iostream>
+
+#include "../cpp/potentialized-unionfind.hpp"
+
+int main() {
+    int n, q;
+    std::cin >> n >> q;
+    UnionFindPlus<long long> uf(n);
+    while (q--) {
+        int t;
+        std::cin >> t;
+        if (t == 0) {
+            int x, y, z;
+            std::cin >> x >> y >> z;
+            uf.merge(x, y, z);
+        } else {
+            int x, y;
+            std::cin >> x >> y;
+            if (uf.same(x, y))
+                std::cout << uf.diff(x, y) << std::endl;
+            else
+                std::cout << '?' << std::endl;
+        }
+    }
+}

test/aoj-jag-summer-2971.test.cpp

@@ -0,0 +1,44 @@
+#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/challenges/sources/JAG/Summer/2971"
+
+#include <array>
+#include <iostream>
+
+#include "../cpp/modint.hpp"
+#include "../cpp/potentialized-unionfind.hpp"
+
+template <typename mint>
+bool solve(int n, const std::vector<std::array<int, 3>>& abx) {
+    UnionFindMul<mint> uf(n);
+    for (auto [a, b, x] : abx) {
+        mint mx = x;
+        if (mx != 0) {
+            if (uf.same(a, b)) {
+                if (uf.diff(a, b) != mx) {
+                    return false;
+                }
+            } else {
+                uf.merge(a, b, mx);
+            }
+        }
+    }
+    return true;
+}
+
+int main() {
+    using mint3 = modint998244353;
+    using mint7 = modint1000000007;
+    using mint9 = static_modint<1000000009U>;
+    int n, m;
+    std::cin >> n >> m;
+    std::vector<std::array<int, 3>> abx(m);
+    for (auto& [a, b, x] : abx) {
+        std::cin >> a >> b >> x;
+        a--;
+        b--;
+    }
+    if (solve<mint3>(n, abx) && solve<mint7>(n, abx) && solve<mint9>(n, abx)) {
+        std::cout << "Yes" << std::endl;
+    } else {
+        std::cout << "No" << std::endl;
+    }
+}