Language: C++

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
#define int ll

#define rep(i,n) for(int i=0;i<n;++i)
#define sort(name) sort(name.begin(), name.end())
#define zero(p) memset(p, 0, sizeof(p))
#define minus(p) memset(p, -1, sizeof(p))
#if 0
#  define dbg(fmt, ...) printf(fmt, ##__va_args__)
#else
#  define dbg(fmt, ...)
#endif

const ll llinf = (1ll<<60);
const int inf = (1ll<<30);
const double dinf = std::numeric_limits<double>::infinity();
const int mod = 1000000007;
#define max_n 100010
#define submit

// ランダム連結グラフ作成
// n 頂点 m 辺の無向連結グラフを作成し edges に辺情報を格納する
// 作成に成功した場合は 0 を返す
// tuple は <0> from, <1> to, <2> cost の順番 (from < to && from != to)
// ノード id は [0, n)
// 辺のコストは [cost_min, cost_max) (※ 半開区間であることに注意)
// n <= 1000, m <= 499500 程度まで作成可能
// o(n^2)
int makeconnectedgraph(mt19937& mt, vector< tuple<ll, ll, ll> >& edges,
        const ll n, const ll m, const ll cost_min, const ll cost_max) {
    if(m - 1 < n && n * (n - 1) / 2 < m) { return -1; }
    edges.clear();

    vector< vector<bool> > graph(n, vector<bool>(n, false) );   // i と j の辺があるなら true
    vector< pair<ll, ll> > pattern;                             // 辺の張り方全パターン

    // まず全ての頂点を連結にする
    vector<ll> connected;
    ll node = (mt() % (n - 1)) + 1;
    ll cost = (mt() % (cost_max - cost_min)) + cost_min;

    connected.push_back(0);
    connected.push_back(node);
    edges.push_back(make_tuple(0, node, cost));
    graph[0][node] = true;

    for(ll i = 1; i < n; ++i) {
        if(i == node) { continue; }
        // 連結済み頂点の中からひとつをランダムに選びそれに接続する
        ll to = connected[mt() % connected.size()];
        cost = (mt() % (cost_max - cost_min)) + cost_min;
        connected.push_back(i);
        edges.push_back(make_tuple(min(i, to), max(i, to), cost));
        graph[min(i, to)][max(i, to)] = true;
    }

    for(ll i = 0; i < n; ++i) {
        for(ll j = i + 1; j < n; ++j) {
            if(!graph[i][j]) { pattern.push_back(make_pair(i, j)); }
        }
    }
    shuffle(pattern.begin(), pattern.end(), mt);

    // まだ辺が引かれていない点どうしに辺を張る
    for(ll i = 0; i < (m - (n - 1)); ++i) {
        cost = (mt() % (cost_max - cost_min)) + cost_min;
        edges.push_back(make_tuple(pattern[i].first, pattern[i].second, cost));
    }
    assert(edges.size() == static_cast<size_t>(m));

    return 0;
}

// 現在位置 cur 現在地 val から行っていないところがあるなら辿る。
// 全部行ったなら true, node_vals とつじつまが合わなくなったら false
bool b_dfs(const vector< vector< pair<ll, ll> > >& graph, vector< vector<bool> >& ischecked,
        vector<ll>& node_vals, ll cur, ll val) {
    node_vals[cur] = val;
    for(auto& dist : graph[cur]) {
        if(!ischecked[cur][dist.first]) {
            ischecked[cur][dist.first] = true;
            ischecked[dist.first][cur] = true;
            ll next_cost = dist.second - val;
            if(next_cost <= 0) { return false; }
            if(node_vals[dist.first] == -1) {
                if(!b_dfs(graph, ischecked, node_vals, dist.first, next_cost)) { return false; }
            } else {
                if(node_vals[dist.first] != next_cost) { return false; }
                if(!b_dfs(graph, ischecked, node_vals, dist.first, next_cost)) { return false; }
            }
        }
    }
    return true;
}

// 愚直な解法
ll blute_force(ll n, ll m, const vector<ll>& u, const vector<ll>& v, const vector<ll>& s) {
    // 隣接リストの作成
    vector< vector< pair<ll, ll> > > graph(n, vector< pair<ll, ll> >());    // to, cost
    rep(i, m) {
        ll from, to, cost;
        from = u[i];
        to = v[i];
        cost = s[i];
        from--; to--;
        graph[from].push_back(make_pair(to, cost));
        graph[to].push_back(make_pair(from, cost));
    }
    // 適当な頂点を始点として全パターンいけるかどうか走査
    ll s = 0;
    ll range_min = -1;
    for(auto& g : graph[s]) { range_min = (range_min == -1) ? g.second : min(range_min, g.second); }
    assert(range_min > 0);

    ll ret = 0;
    for(ll i = 1; i < range_min; ++i) {
        vector<ll> node_vals(n, -1);
        vector< vector<bool> > ischecked(2 * m, vector<bool>(2 * m, false) );
        if(b_dfs(graph, ischecked, node_vals, s, i)) { ret++; }
    }

    return ret;
}

const pair<ll, ll> init_pair = make_pair(-1, -1);

enum order { ascending, descending, equal };    // 昇順、降順、同値

// range[to] と range[from] の範囲を比べて、重なる部分を range[to] に設定する
// range[to] が初期状態なら、適切な値を設定する
// 範囲の条件に齟齬があるときは false が返る
bool update(vector< pair<ll, ll> >& range, ll from, ll to, ll cost) {
    dbg("update from: %lld [%lld, %lld] to: %lld [%lld, %lld] cost: %lld\n",
            from, range[from].first, range[from].second,
            to, range[to].first, range[to].second, cost);
    if(range[to] == init_pair) {
        range[to].first = cost - range[from].first;
        range[to].second= cost - range[from].second;
        if(max(range[to].first, range[to].second) <= 0) {
            dbg("false 1\n");
            return false;
        }
        if(range[to].first <= 0) { range[to].first = 1; }
        if(range[to].second <= 0) { range[to].second = 1; }

        range[from].first = cost - range[to].first;
        range[from].second = cost - range[to].second;
        if(max(range[from].first, range[from].second) <= 0) {
            dbg("false 2\n");
            return false;
        }
        if(range[from].first <= 0) { range[from].first = 1; }
        if(range[from].second <= 0) { range[from].second = 1; }
        dbg("  -> to: [%lld, %lld]\n", range[to].first, range[to].second);
        return true;
    }
    pair<ll, ll> cand;  // from 側からみて to になってほしい値の範囲
    cand.first = cost - range[from].first;
    cand.second = cost - range[from].second;
    if(max(cand.first, cand.second) <= 0) {
        dbg("false 3\n");
        return false;
    }

    int candorder = equal;
    int toorder = equal;
    if(cand.first < cand.second) { candorder = ascending; }
    else if(cand.first > cand.second) { candorder = descending; }
    if(range[to].first < range[to].second) { toorder = ascending; }
    else if(range[to].first > range[to].second) { toorder = descending; }

    // 値の範囲がただひとつのとき
    if(candorder == equal) {
        if(toorder == equal) {
            if(cand.first == range[to].first) {
                dbg("  -> to: nochange\n");
                return true;
            }
            dbg("false 4\n");
            return false;
        }
        else if(toorder == ascending){
            if(range[to].first <= cand.first && cand.first <= range[to].second) {
                range[to] = cand;
                // from へのフィードバック
                range[from].first = cost - range[to].first;
                range[from].second = cost - range[to].second;
                if(max(range[from].first, range[from].second) <= 0) {
                    dbg("false 5\n");
                    return false;
                }
                if(range[from].first <= 0) { range[from].first = 1; }
                if(range[from].second <= 0) { range[from].second = 1; }
                dbg("  -> to: [%lld, %lld]\n", range[to].first, range[to].second);
                return true;
            }
            dbg("false 6\n");
            return false;
        }
        else {
            if(range[to].second <= cand.first && cand.first<= range[to].first) {
                range[to] = cand;
                // from へのフィードバック
                range[from].first = cost - range[to].first;
                range[from].second = cost - range[to].second;
                if(max(range[from].first, range[from].second) <= 0) {
                    dbg("false 7\n");
                    return false;
                }
                if(range[from].first <= 0) { range[from].first = 1; }
                if(range[from].second <= 0) { range[from].second = 1; }
                dbg("  -> to: [%lld, %lld]\n", range[to].first, range[to].second);
                return true;
            }
            dbg("false 8\n");
            return false;
        }
    }
    if(toorder == equal) {
        if(candorder == ascending) {
            if(cand.first <= range[to].first && range[to].first <= cand.second) {
                // from へのフィードバック
                range[from].first = cost - range[to].first;
                range[from].second = cost - range[to].second;
                if(max(range[from].first, range[from].second) <= 0) {
                    dbg("false 9\n");
                    return false;
                }
                if(range[from].first <= 0) { range[from].first = 1; }
                if(range[from].second <= 0) { range[from].second = 1; }
                dbg("  -> to: [%lld, %lld]\n", range[to].first, range[to].second);
                return true;
            }
            dbg("false 10\n");
            return false;
        }
        else if(candorder == descending) {
            if(cand.second <= range[to].first && range[to].first<= cand.first) {
                // from へのフィードバック
                range[from].first = cost - range[to].first;
                range[from].second = cost - range[to].second;
                if(max(range[from].first, range[from].second) <= 0) {
                    dbg("false 11\n");
                    return false;
                }
                if(range[from].first <= 0) { range[from].first = 1; }
                if(range[from].second <= 0) { range[from].second = 1; }
                dbg("  -> to: [%lld, %lld]\n", range[to].first, range[to].second);
                return true;
            }
            dbg("false 12\n");
            return false;
        }
        assert(false);
    }

    // 範囲の order が同じなら、狭い方を採用
    if(candorder == toorder) {
        if(candorder == ascending) {
            range[to].first = max(range[to].first, cand.first);
            range[to].second = min(range[to].second, cand.second);
            if(range[to].first > range[to].second) {
                dbg("false 13\n");
                return false;
            }
        } else {
            range[to].first = min(range[to].first, cand.first);
            range[to].second = max(range[to].second, cand.second);
            if(range[to].first < range[to].second) {
                dbg("false 14\n");
                return false;
            }
        }
        // from へのフィードバック
        range[from].first = cost - range[to].first;
        range[from].second = cost - range[to].second;
        if(max(range[from].first, range[from].second) <= 0) {
            dbg("false 15\n");
            return false;
        }
        if(range[from].first <= 0) { range[from].first = 1; }
        if(range[from].second <= 0) { range[from].second = 1; }
    }
    else {
        // order が異なるなら、一意になるはず
        if(range[to].first == cand.first) {
            range[to].second = range[to].first;
        }
        else if(range[to].second == cand.second) {
            range[to].first = range[to].second;
        }
        else {
            pair<ll, ll> big_range = range[to];     // 範囲がデカい方
            pair<ll, ll> small_range = cand;
            if(abs(big_range.first - big_range.second) < abs(small_range.first - small_range.second)) {
                swap(big_range, small_range);
            }
            ll small_length = abs(small_range.first - small_range.second) + 1;
            dbg("big_range: %lld %lld\n", big_range.first, big_range.second);
            dbg("small_range: %lld %lld\n", small_range.first, small_range.second);
            ll val = big_range.first + small_range.first;
            if(big_range.first > big_range.second) {
                val = big_range.second + small_range.second;
            }
            if(val % 2 == 0) {
                range[to].first = val / 2;
                range[to].second = range[to].first;
            } else {
                dbg("false 16\n");
                return false;
            }
        }

        // from へのフィードバック
        range[from].first = cost - range[to].first;
        range[from].second = cost - range[to].second;
        if(max(range[from].first, range[from].second) <= 0) {
            dbg("false 17\n");
            return false;
        }
        if(range[from].first <= 0) { range[from].first = 1; }
        if(range[from].second <= 0) { range[from].second = 1; }
    }

    dbg("  -> to: [%lld, %lld]\n", range[to].first, range[to].second);
    return true;
}

ll solve(ll n, ll m, const vector<ll>& u, const vector<ll>& v, const vector<ll>& s) {
    vector< vector< pair<ll, ll> > > graph(n, vector< pair<ll, ll> >());    // to, cost
    vector< pair<ll, ll> > range(n, pair<ll, ll>());  // i に許された値の範囲(閉区間)

    // 隣接リストの作成
    rep(i, m) {
        ll from, to, cost;
        from = u[i];
        to = v[i];
        cost = s[i];
        from--; to--;
        graph[from].push_back(make_pair(to, cost));
        graph[to].push_back(make_pair(from, cost));
    }
    rep(i, n) {
        range[i] = init_pair;
    }

    // 適当な頂点を始点にして幅優先探索
    range[0] = make_pair(1, graph[0][0].second - 1);
    rep(l, 4) {
        dbg("--- loop %lld ---\n", l + 1);
        vector<bool> ischecked(n, false);
        queue<ll> que;
        que.push(0);
        while(!que.empty()) {
            ll from = que.front();
            que.pop();
            ischecked[from] = true;
            for(auto& next_n : graph[from]) {
                ll to = next_n.first;
                ll cost = next_n.second;
                if(range[to] != init_pair) {
                    // すでに値が入っているなら、値を更新
                    if(!update(range, from, to, cost)) {
                        // つじつまが合わないなら終了
                        return 0;
                    }
                }
                else {
                    // 初到達頂点なら range を設定
                    if(!update(range, from, to, cost)) {
                        return 0;
                    }
                    //que.push(to);
                }
                if(!ischecked[to]) { que.push(to); }
            }
        }
    }

    ll ans = llinf;
    rep(i, n) {
        if(range[i] != init_pair) {
            ans = min(ans, abs(range[i].second - range[i].first) + 1);
        }
    }

    return ans;
}

signed main()
{
#ifdef submit
    // 提出用コード
    ll n, m;
    cin >> n >> m;
    vector<ll> u(m, 0);
    vector<ll> v(m, 0);
    vector<ll> s(m, 0);
    rep(i, m) {
        cin >> u[i] >> v[i] >> s[i];
    }

    //printf("%lld\n", solve(n, m, u, v, s));
    printf("%lld\n", blute_force(n, m, u, v, s));
#else
    // 検証用コード
    vector< tuple<ll, ll, ll> > edges;
    random_device r;
    mt19937 mt(r());
    const int loop = 1000;
    ll n = 7;
    ll val_range = n * (n-1) / 2 - (n - 1);
    ll m = 6; //mt() % val_range + n - 1;
    rep(l, loop) {
        ll ret = makeconnectedgraph(mt, edges, n, m, 2, 101);
        assert(ret == 0);
        vector<ll> u(m, 0);
        vector<ll> v(m, 0);
        vector<ll> s(m, 0);
        rep(i, edges.size()) {
            u[i] = get<0>(edges[i]);
            v[i] = get<1>(edges[i]);
            s[i] = get<2>(edges[i]);
            u[i]++; v[i]++;
        }
        ll cand = solve(n, m, u, v, s);
        ll ans = blute_force(n, m, u, v, s);
        if(cand != ans) {
            printf("%lld %lld\n", n, m);
            rep(i, m) {
                printf("%lld %lld %lld\n", u[i], v[i], s[i]);
            }
            printf("cand: %lld ans: %lld\n", cand, ans);
            break;
        }
    }

#endif

    return 0;
}


Compiler output:
a.cc: In function 'll blute_force(ll, ll, const std::vector<long long int>&, const std::vector<long long int>&, const std::vector<long long int>&)':
a.cc:113:8: error: declaration of 'll s' shadows a parameter
  113 |     ll s = 0;
      |        ^
a.cc:100:88: note: 'const std::vector<long long int>& s' previously declared here
  100 | ll blute_force(ll n, ll m, const vector<ll>& u, const vector<ll>& v, const vector<ll>& s) {
      |                                                                      ~~~~~~~~~~~~~~~~~~^
a.cc: In function 'bool update(std::vector<std::pair<long long int, long long int> >&, ll, ll, ll)':
a.cc:168:21: error: reference to 'equal' is ambiguous
  168 |     int candorder = equal;
      |                     ^~~~~
In file included from /usr/include/c++/14/algorithm:86,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/pstl/glue_algorithm_defs.h:347:1: note: candidates are: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2)'
  347 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:342:1: note:                 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate)'
  342 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:338:1: note:                 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2)'
  338 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
      | ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:333:1: note:                 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate)'
  333 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~
In file included from /usr/include/c++/14/algorithm:60:
/usr/include/c++/14/bits/stl_algobase.h:1737:5: note:                 'template<class _IIter1, class _IIter2, class _BinaryPredicate> bool std::equal(_IIter1, _IIter1, _IIter2, _IIter2, _BinaryPredicate)'
 1737 |     equal(_IIter1 __first1, _IIter1 __last1,
      |     ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1704:5: note:                 'template<class _II1, class _II2> bool std::equal(_II1, _II1, _II2, _II2)'
 1704 |     equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
      |     ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1613:5: note:                 'template<class _IIter1, class _IIter2, class _BinaryPredicate> bool std::equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate)'
 1613 |     equal(_IIter1 __first1, _IIter1 __last1,
      |     ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1582:5: note:                 'template<class _II1, class _II2> bool std::equal(_II1, _II1, _II2)'
 1582 |     equal(_II1 __first1, _II1 __last1, _II2 __first2)
      |     ^~~~~
a.cc:130:37: note:                 'order equal'
  130 | enum order { ascending, descending, equal };    // 昇順、降順、同値
      |                                     ^~~~~
a.cc:169:19: error: reference to 'equal' is ambiguous
  169 |     int toorder = equal;
      |                   ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:347:1: note: candidates are: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2)'
  347 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:342:1: note:                 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate)'
  342 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:338:1: note:                 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2)'
  338 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
      | ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:333:1: note:                 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate)'
  333 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1737:5: note:                 'template<class _IIter1, class _IIter2, class _BinaryPredicate> bool std::equal(_IIter1, _IIter1, _IIter2, _IIter2, _BinaryPredicate)'
 1737 |     equal(_IIter1 __first1, _IIter1 __last1,
      |     ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1704:5: note:                 'template<class _II1, class _II2> bool std::equal(_II1, _II1, _II2, _II2)'
 1704 |     equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
      |     ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1613:5: note:                 'template<class _IIter1, class _IIter2, class _BinaryPredicate> bool std::equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate)'
 1613 |     equal(_IIter1 __first1, _IIter1 __last1,
      |     ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1582:5: note:                 'template<class _II1, class _II2> bool std::equal(_II1, _II1, _II2)'
 1582 |     equal(_II1 __first1, _II1 __last1, _II2 __first2)
      |     ^~~~~
a.cc:130:37: note:                 'order equal'
  130 | enum order { ascending, descending, equal };    // 昇順、降順、同値
      |                                     ^~~~~
a.cc:176:21: error: reference to 'equal' is ambiguous
  176 |     if(candorder == equal) {
      |                     ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:347:1: note: candidates are: 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2)'
  347 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:342:1: note:                 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate)'
  342 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:338:1: note:                 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2)'
  338 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
      | ^~~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:333:1: note:                 'template<class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> std::equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate)'
  333 | equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      | ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1737:5: note:                 'template<class _IIter1, class _IIter2, class _BinaryPredicate> bool std::equal(_IIter1, _IIter1, _IIter2, _IIter2, _BinaryPredicate)'
 1737 |     equal(_IIter1 __first1, _IIter1 __last1,
      |     ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1704:5: note:                 'template<class _II1, class _II2> bool std::equal(_II1, _II1, _II2, _II2)'
 1704 |     equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
      |     ^~~~~
/usr/include/c++/14/bits/stl_algobase.h:1613:5: note:                 'template<class _IIter1, class _IIter2, class _BinaryPredicate> bool std::equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate)'
 1613 |     equal(_IIter1 __first1, _IIter1 __last1,