結果
| 問題 |
No.1784 Not a star yet...
|
| コンテスト | |
| ユーザー |
 NyaanNyaan
|
| 提出日時 | 2021-11-23 21:40:03 |
| 言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
MLE
|
| 実行時間 | - |
| コード長 | 36,978 bytes |
| コンパイル時間 | 7,679 ms |
| コンパイル使用メモリ | 296,672 KB |
| 最終ジャッジ日時 | 2025-01-26 00:48:49 |
|
ジャッジサーバーID （参考情報） |
judge1 / judge2 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 25 TLE * 11 MLE * 25 |
コンパイルメッセージ
main.cpp:1002:7: warning: ‘template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator’ is deprecated [-Wdeprecated-declarations]
1002 | : iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&> {
| ^~~~~~~~
In file included from /usr/include/c++/13/bits/stl_algobase.h:65,
from /usr/include/c++/13/algorithm:60,
from main.cpp:11:
/usr/include/c++/13/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
main.cpp:1004:7: warning: ‘template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator’ is deprecated [-Wdeprecated-declarations]
1004 | iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&>;
| ^~~~~~~~
/usr/include/c++/13/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
ソースコード
/**
* date : 2021-11-23 21:39:57
*/
#define NDEBUG
using namespace std;
// intrinstic
#include <immintrin.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// utility
namespace Nyaan {
using ll = long long;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<vector<T>>;
using vi = vector<int>;
using vl = vector<long long>;
using vd = V<double>;
using vs = V<string>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<long long>>;
template <typename T, typename U>
struct P : pair<T, U> {
template <typename... Args>
P(Args... args) : pair<T, U>(args...) {}
using pair<T, U>::first;
using pair<T, U>::second;
T &x() { return first; }
const T &x() const { return first; }
U &y() { return second; }
const U &y() const { return second; }
P &operator+=(const P &r) {
first += r.first;
second += r.second;
return *this;
}
P &operator-=(const P &r) {
first -= r.first;
second -= r.second;
return *this;
}
P &operator*=(const P &r) {
first *= r.first;
second *= r.second;
return *this;
}
P operator+(const P &r) const { return P(*this) += r; }
P operator-(const P &r) const { return P(*this) -= r; }
P operator*(const P &r) const { return P(*this) *= r; }
};
using pl = P<ll, ll>;
using pi = P<int, int>;
using vp = V<pl>;
constexpr int inf = 1001001001;
constexpr long long infLL = 4004004004004004004LL;
template <typename T>
int sz(const T &t) {
return t.size();
}
template <typename T, typename U>
inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U>
inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T>
inline T Max(const vector<T> &v) {
return *max_element(begin(v), end(v));
}
template <typename T>
inline T Min(const vector<T> &v) {
return *min_element(begin(v), end(v));
}
template <typename T>
inline long long Sum(const vector<T> &v) {
return accumulate(begin(v), end(v), 0LL);
}
template <typename T>
int lb(const vector<T> &v, const T &a) {
return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T>
int ub(const vector<T> &v, const T &a) {
return upper_bound(begin(v), end(v), a) - begin(v);
}
constexpr long long TEN(int n) {
long long ret = 1, x = 10;
for (; n; x *= x, n >>= 1) ret *= (n & 1 ? x : 1);
return ret;
}
template <typename T, typename U>
pair<T, U> mkp(const T &t, const U &u) {
return make_pair(t, u);
}
template <typename T>
vector<T> mkrui(const vector<T> &v, bool rev = false) {
vector<T> ret(v.size() + 1);
if (rev) {
for (int i = int(v.size()) - 1; i >= 0; i--) ret[i] = v[i] + ret[i + 1];
} else {
for (int i = 0; i < int(v.size()); i++) ret[i + 1] = ret[i] + v[i];
}
return ret;
};
template <typename T>
vector<T> mkuni(const vector<T> &v) {
vector<T> ret(v);
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
template <typename F>
vector<int> mkord(int N, F f) {
vector<int> ord(N);
iota(begin(ord), end(ord), 0);
sort(begin(ord), end(ord), f);
return ord;
}
template <typename T>
vector<int> mkinv(vector<T> &v) {
int max_val = *max_element(begin(v), end(v));
vector<int> inv(max_val + 1, -1);
for (int i = 0; i < (int)v.size(); i++) inv[v[i]] = i;
return inv;
}
} // namespace Nyaan
// bit operation
namespace Nyaan {
__attribute__((target("popcnt"))) inline int popcnt(const u64 &a) {
return _mm_popcnt_u64(a);
}
inline int lsb(const u64 &a) { return a ? __builtin_ctzll(a) : 64; }
inline int ctz(const u64 &a) { return a ? __builtin_ctzll(a) : 64; }
inline int msb(const u64 &a) { return a ? 63 - __builtin_clzll(a) : -1; }
template <typename T>
inline int gbit(const T &a, int i) {
return (a >> i) & 1;
}
template <typename T>
inline void sbit(T &a, int i, bool b) {
if (gbit(a, i) != b) a ^= T(1) << i;
}
constexpr long long PW(int n) { return 1LL << n; }
constexpr long long MSK(int n) { return (1LL << n) - 1; }
} // namespace Nyaan
// inout
namespace Nyaan {
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (int i = 0; i < s; i++) os << (i ? " " : "") << v[i];
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
void in() {}
template <typename T, class... U>
void in(T &t, U &... u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U, char sep = ' '>
void out(const T &t, const U &... u) {
cout << t;
if (sizeof...(u)) cout << sep;
out(u...);
}
void outr() {}
template <typename T, class... U, char sep = ' '>
void outr(const T &t, const U &... u) {
cout << t;
outr(u...);
}
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
} // namespace Nyaan
// debug
namespace DebugImpl {
template <typename U, typename = void>
struct is_specialize : false_type {};
template <typename U>
struct is_specialize<
U, typename conditional<false, typename U::iterator, void>::type>
: true_type {};
template <typename U>
struct is_specialize<
U, typename conditional<false, decltype(U::first), void>::type>
: true_type {};
template <typename U>
struct is_specialize<U, enable_if_t<is_integral<U>::value, void>> : true_type {
};
void dump(const char& t) { cerr << t; }
void dump(const string& t) { cerr << t; }
void dump(const bool& t) { cerr << (t ? "true" : "false"); }
template <typename U,
enable_if_t<!is_specialize<U>::value, nullptr_t> = nullptr>
void dump(const U& t) {
cerr << t;
}
template <typename T>
void dump(const T& t, enable_if_t<is_integral<T>::value>* = nullptr) {
string res;
if (t == Nyaan::inf) res = "inf";
if constexpr (is_signed<T>::value) {
if (t == -Nyaan::inf) res = "-inf";
}
if constexpr (sizeof(T) == 8) {
if (t == Nyaan::infLL) res = "inf";
if constexpr (is_signed<T>::value) {
if (t == -Nyaan::infLL) res = "-inf";
}
}
if (res.empty()) res = to_string(t);
cerr << res;
}
template <typename T, typename U>
void dump(const pair<T, U>&);
template <typename T>
void dump(const pair<T*, int>&);
template <typename T>
void dump(const T& t,
enable_if_t<!is_void<typename T::iterator>::value>* = nullptr) {
cerr << "[ ";
for (auto it = t.begin(); it != t.end();) {
dump(*it);
cerr << (++it == t.end() ? "" : ", ");
}
cerr << " ]";
}
template <typename T, typename U>
void dump(const pair<T, U>& t) {
cerr << "( ";
dump(t.first);
cerr << ", ";
dump(t.second);
cerr << " )";
}
template <typename T>
void dump(const pair<T*, int>& t) {
cerr << "[ ";
for (int i = 0; i < t.second; i++) {
dump(t.first[i]);
cerr << (i == t.second - 1 ? "" : ", ");
}
cerr << " ]";
}
void trace() { cerr << endl; }
template <typename Head, typename... Tail>
void trace(Head&& head, Tail&&... tail) {
cerr << " ";
dump(head);
if (sizeof...(tail) != 0) cerr << ",";
trace(forward<Tail>(tail)...);
}
} // namespace DebugImpl
#ifdef NyaanDebug
#define trc(...) \
do { \
cerr << "## " << #__VA_ARGS__ << " = "; \
DebugImpl::trace(__VA_ARGS__); \
} while (0)
#else
#define trc(...) (void(0))
#endif
// macro
#define each(x, v) for (auto&& x : v)
#define each2(x, y, v) for (auto&& [x, y] : v)
#define all(v) (v).begin(), (v).end()
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define regr(i, a, b) for (long long i = (b)-1; i >= (a); i--)
#define fi first
#define se second
#define ini(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define inl(...) \
long long __VA_ARGS__; \
in(__VA_ARGS__)
#define ins(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define in2(s, t) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i]); \
}
#define in3(s, t, u) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i]); \
}
#define in4(s, t, u, v) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i], v[i]); \
}
#define die(...) \
do { \
Nyaan::out(__VA_ARGS__); \
return; \
} while (0)
namespace Nyaan {
void solve();
}
int main() { Nyaan::solve(); }
//
template <typename T>
struct edge {
int src, to;
T cost;
edge(int _to, T _cost) : src(-1), to(_to), cost(_cost) {}
edge(int _src, int _to, T _cost) : src(_src), to(_to), cost(_cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T>>;
template <typename T>
using WeightedGraph = vector<Edges<T>>;
using UnweightedGraph = vector<vector<int>>;
// Input of (Unweighted) Graph
UnweightedGraph graph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
UnweightedGraph g(N);
if (M == -1) M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
if (is_1origin) x--, y--;
g[x].push_back(y);
if (!is_directed) g[y].push_back(x);
}
return g;
}
// Input of Weighted Graph
template <typename T>
WeightedGraph<T> wgraph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
WeightedGraph<T> g(N);
if (M == -1) M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
cin >> c;
if (is_1origin) x--, y--;
g[x].emplace_back(x, y, c);
if (!is_directed) g[y].emplace_back(y, x, c);
}
return g;
}
// Input of Edges
template <typename T>
Edges<T> esgraph(int N, int M, int is_weighted = true, bool is_1origin = true) {
Edges<T> es;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
if (is_weighted)
cin >> c;
else
c = 1;
if (is_1origin) x--, y--;
es.emplace_back(x, y, c);
}
return es;
}
// Input of Adjacency Matrix
template <typename T>
vector<vector<T>> adjgraph(int N, int M, T INF, int is_weighted = true,
bool is_directed = false, bool is_1origin = true) {
vector<vector<T>> d(N, vector<T>(N, INF));
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
if (is_weighted)
cin >> c;
else
c = 1;
if (is_1origin) x--, y--;
d[x][y] = c;
if (!is_directed) d[y][x] = c;
}
return d;
}
// 一般のグラフのstからの距離！！！！
// unvisited nodes : d = -1
vector<int> Depth(const UnweightedGraph &g, int start = 0) {
int n = g.size();
vector<int> ds(n, -1);
ds[start] = 0;
queue<int> q;
q.push(start);
while (!q.empty()) {
int c = q.front();
q.pop();
int dc = ds[c];
for (auto &d : g[c]) {
if (ds[d] == -1) {
ds[d] = dc + 1;
q.push(d);
}
}
}
return ds;
}
// Depth of Rooted Weighted Tree
// unvisited nodes : d = -1
template <typename T>
vector<T> Depth(const WeightedGraph<T> &g, int start = 0) {
vector<T> d(g.size(), -1);
auto dfs = [&](auto rec, int cur, T val, int par = -1) -> void {
d[cur] = val;
for (auto &dst : g[cur]) {
if (dst == par) continue;
rec(rec, dst, val + dst.cost, cur);
}
};
dfs(dfs, start, 0);
return d;
}
// Diameter of Tree
// return value : { {u, v}, length }
pair<pair<int, int>, int> Diameter(const UnweightedGraph &g) {
auto d = Depth(g, 0);
int u = max_element(begin(d), end(d)) - begin(d);
d = Depth(g, u);
int v = max_element(begin(d), end(d)) - begin(d);
return make_pair(make_pair(u, v), d[v]);
}
// Diameter of Weighted Tree
// return value : { {u, v}, length }
template <typename T>
pair<pair<int, int>, T> Diameter(const WeightedGraph<T> &g) {
auto d = Depth(g, 0);
int u = max_element(begin(d), end(d)) - begin(d);
d = Depth(g, u);
int v = max_element(begin(d), end(d)) - begin(d);
return make_pair(make_pair(u, v), d[v]);
}
// nodes on the path u-v ( O(N) )
template <typename G>
vector<int> Path(G &g, int u, int v) {
vector<int> ret;
int end = 0;
auto dfs = [&](auto rec, int cur, int par = -1) -> void {
ret.push_back(cur);
if (cur == v) {
end = 1;
return;
}
for (int dst : g[cur]) {
if (dst == par) continue;
rec(rec, dst, cur);
if (end) return;
}
if (end) return;
ret.pop_back();
};
dfs(dfs, u);
return ret;
}
__attribute__((target("sse4.2"))) inline __m128i my128_mullo_epu32(
const __m128i &a, const __m128i &b) {
return _mm_mullo_epi32(a, b);
}
__attribute__((target("sse4.2"))) inline __m128i my128_mulhi_epu32(
const __m128i &a, const __m128i &b) {
__m128i a13 = _mm_shuffle_epi32(a, 0xF5);
__m128i b13 = _mm_shuffle_epi32(b, 0xF5);
__m128i prod02 = _mm_mul_epu32(a, b);
__m128i prod13 = _mm_mul_epu32(a13, b13);
__m128i prod = _mm_unpackhi_epi64(_mm_unpacklo_epi32(prod02, prod13),
_mm_unpackhi_epi32(prod02, prod13));
return prod;
}
__attribute__((target("sse4.2"))) inline __m128i montgomery_mul_128(
const __m128i &a, const __m128i &b, const __m128i &r, const __m128i &m1) {
return _mm_sub_epi32(
_mm_add_epi32(my128_mulhi_epu32(a, b), m1),
my128_mulhi_epu32(my128_mullo_epu32(my128_mullo_epu32(a, b), r), m1));
}
__attribute__((target("sse4.2"))) inline __m128i montgomery_add_128(
const __m128i &a, const __m128i &b, const __m128i &m2, const __m128i &m0) {
__m128i ret = _mm_sub_epi32(_mm_add_epi32(a, b), m2);
return _mm_add_epi32(_mm_and_si128(_mm_cmpgt_epi32(m0, ret), m2), ret);
}
__attribute__((target("sse4.2"))) inline __m128i montgomery_sub_128(
const __m128i &a, const __m128i &b, const __m128i &m2, const __m128i &m0) {
__m128i ret = _mm_sub_epi32(a, b);
return _mm_add_epi32(_mm_and_si128(_mm_cmpgt_epi32(m0, ret), m2), ret);
}
__attribute__((target("avx2"))) inline __m256i my256_mullo_epu32(
const __m256i &a, const __m256i &b) {
return _mm256_mullo_epi32(a, b);
}
__attribute__((target("avx2"))) inline __m256i my256_mulhi_epu32(
const __m256i &a, const __m256i &b) {
__m256i a13 = _mm256_shuffle_epi32(a, 0xF5);
__m256i b13 = _mm256_shuffle_epi32(b, 0xF5);
__m256i prod02 = _mm256_mul_epu32(a, b);
__m256i prod13 = _mm256_mul_epu32(a13, b13);
__m256i prod = _mm256_unpackhi_epi64(_mm256_unpacklo_epi32(prod02, prod13),
_mm256_unpackhi_epi32(prod02, prod13));
return prod;
}
__attribute__((target("avx2"))) inline __m256i montgomery_mul_256(
const __m256i &a, const __m256i &b, const __m256i &r, const __m256i &m1) {
return _mm256_sub_epi32(
_mm256_add_epi32(my256_mulhi_epu32(a, b), m1),
my256_mulhi_epu32(my256_mullo_epu32(my256_mullo_epu32(a, b), r), m1));
}
__attribute__((target("avx2"))) inline __m256i montgomery_add_256(
const __m256i &a, const __m256i &b, const __m256i &m2, const __m256i &m0) {
__m256i ret = _mm256_sub_epi32(_mm256_add_epi32(a, b), m2);
return _mm256_add_epi32(_mm256_and_si256(_mm256_cmpgt_epi32(m0, ret), m2),
ret);
}
__attribute__((target("avx2"))) inline __m256i montgomery_sub_256(
const __m256i &a, const __m256i &b, const __m256i &m2, const __m256i &m0) {
__m256i ret = _mm256_sub_epi32(a, b);
return _mm256_add_epi32(_mm256_and_si256(_mm256_cmpgt_epi32(m0, ret), m2),
ret);
}
namespace Gauss {
uint32_t a_buf_[4096][4096] __attribute__((aligned(64)));
// return value: (rank, (-1) ^ (number of swap time))
template <typename mint>
__attribute__((target("avx2"))) pair<int, mint> GaussianElimination(
const vector<vector<mint>> &m, int LinearEquation = false) {
mint(&a)[4096][4096] = *reinterpret_cast<mint(*)[4096][4096]>(a_buf_);
int H = m.size(), W = m[0].size(), rank = 0;
mint det = 1;
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++) a[i][j].a = m[i][j].a;
__m256i r = _mm256_set1_epi32(mint::r);
__m256i m0 = _mm256_set1_epi32(0);
__m256i m1 = _mm256_set1_epi32(mint::get_mod());
__m256i m2 = _mm256_set1_epi32(mint::get_mod() << 1);
for (int j = 0; j < (LinearEquation ? (W - 1) : W); j++) {
// find basis
if (rank == H) break;
int idx = -1;
for (int i = rank; i < H; i++) {
if (a[i][j].get() != 0) {
idx = i;
break;
}
}
if (idx == -1) {
det = 0;
continue;
}
// swap
if (rank != idx) {
det = -det;
for (int l = j; l < W; l++) swap(a[rank][l], a[idx][l]);
}
det *= a[rank][j];
// normalize
if (LinearEquation) {
if (a[rank][j].get() != 1) {
mint coeff = a[rank][j].inverse();
__m256i COEFF = _mm256_set1_epi32(coeff.a);
for (int i = j / 8 * 8; i < W; i += 8) {
__m256i R = _mm256_load_si256((__m256i *)(a[rank] + i));
__m256i RmulC = montgomery_mul_256(R, COEFF, r, m1);
_mm256_store_si256((__m256i *)(a[rank] + i), RmulC);
}
}
}
// elimination
for (int k = (LinearEquation ? 0 : rank + 1); k < H; k++) {
if (k == rank) continue;
if (a[k][j].get() != 0) {
mint coeff = a[k][j] / a[rank][j];
__m256i COEFF = _mm256_set1_epi32(coeff.a);
for (int i = j / 8 * 8; i < W; i += 8) {
__m256i R = _mm256_load_si256((__m256i *)(a[rank] + i));
__m256i K = _mm256_load_si256((__m256i *)(a[k] + i));
__m256i RmulC = montgomery_mul_256(R, COEFF, r, m1);
__m256i KmnsR = montgomery_sub_256(K, RmulC, m2, m0);
_mm256_store_si256((__m256i *)(a[k] + i), KmnsR);
}
}
}
rank++;
}
return {rank, det};
}
// calculate determinant
template <typename mint>
mint determinant(const vector<vector<mint>> &mat) {
return GaussianElimination(mat).second;
}
// return V<V<mint>>
// 0 column ... one of solutions
// 1 ~ (W - rank) column ... bases
// if not exist, return empty vector
template <typename mint>
vector<vector<mint>> LinearEquation(vector<vector<mint>> A, vector<mint> B) {
int H = A.size(), W = A[0].size();
for (int i = 0; i < H; i++) A[i].push_back(B[i]);
auto p = GaussianElimination(A, true);
mint(&a)[4096][4096] = *reinterpret_cast<mint(*)[4096][4096]>(a_buf_);
int rank = p.first;
// check if solutions exist
for (int i = rank; i < H; ++i)
if (a[i][W] != 0) return vector<vector<mint>>{};
vector<vector<mint>> res(1, vector<mint>(W));
vector<int> pivot(W, -1);
for (int i = 0, j = 0; i < rank; ++i) {
while (a[i][j] == 0) ++j;
res[0][j] = a[i][W], pivot[j] = i;
}
for (int j = 0; j < W; ++j) {
if (pivot[j] == -1) {
vector<mint> x(W);
x[j] = 1;
for (int k = 0; k < j; ++k)
if (pivot[k] != -1) x[k] = -a[pivot[k]][j];
res.push_back(x);
}
}
return res;
}
} // namespace Gauss
using Gauss::determinant;
using Gauss::LinearEquation;
//#include "matrix/linear-equation.hpp"
//
using namespace Nyaan;
template <uint32_t mod>
struct LazyMontgomeryModInt {
using mint = LazyMontgomeryModInt;
using i32 = int32_t;
using u32 = uint32_t;
using u64 = uint64_t;
static constexpr u32 get_r() {
u32 ret = mod;
for (i32 i = 0; i < 4; ++i) ret *= 2 - mod * ret;
return ret;
}
static constexpr u32 r = get_r();
static constexpr u32 n2 = -u64(mod) % mod;
static_assert(r * mod == 1, "invalid, r * mod != 1");
static_assert(mod < (1 << 30), "invalid, mod >= 2 ^ 30");
static_assert((mod & 1) == 1, "invalid, mod % 2 == 0");
u32 a;
constexpr LazyMontgomeryModInt() : a(0) {}
constexpr LazyMontgomeryModInt(const int64_t &b)
: a(reduce(u64(b % mod + mod) * n2)){};
static constexpr u32 reduce(const u64 &b) {
return (b + u64(u32(b) * u32(-r)) * mod) >> 32;
}
constexpr mint &operator+=(const mint &b) {
if (i32(a += b.a - 2 * mod) < 0) a += 2 * mod;
return *this;
}
constexpr mint &operator-=(const mint &b) {
if (i32(a -= b.a) < 0) a += 2 * mod;
return *this;
}
constexpr mint &operator*=(const mint &b) {
a = reduce(u64(a) * b.a);
return *this;
}
constexpr mint &operator/=(const mint &b) {
*this *= b.inverse();
return *this;
}
constexpr mint operator+(const mint &b) const { return mint(*this) += b; }
constexpr mint operator-(const mint &b) const { return mint(*this) -= b; }
constexpr mint operator*(const mint &b) const { return mint(*this) *= b; }
constexpr mint operator/(const mint &b) const { return mint(*this) /= b; }
constexpr bool operator==(const mint &b) const {
return (a >= mod ? a - mod : a) == (b.a >= mod ? b.a - mod : b.a);
}
constexpr bool operator!=(const mint &b) const {
return (a >= mod ? a - mod : a) != (b.a >= mod ? b.a - mod : b.a);
}
constexpr mint operator-() const { return mint() - mint(*this); }
constexpr mint pow(u64 n) const {
mint ret(1), mul(*this);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
constexpr mint inverse() const { return pow(mod - 2); }
friend ostream &operator<<(ostream &os, const mint &b) {
return os << b.get();
}
friend istream &operator>>(istream &is, mint &b) {
int64_t t;
is >> t;
b = LazyMontgomeryModInt<mod>(t);
return (is);
}
constexpr u32 get() const {
u32 ret = reduce(a);
return ret >= mod ? ret - mod : ret;
}
static constexpr u32 get_mod() { return mod; }
};
template <typename T>
struct Binomial {
vector<T> f, g, h;
Binomial(int MAX = 0) : f(1, T(1)), g(1, T(1)), h(1, T(1)) {
while (MAX >= (int)f.size()) extend();
}
void extend() {
int n = f.size();
int m = n * 2;
f.resize(m);
g.resize(m);
h.resize(m);
for (int i = n; i < m; i++) f[i] = f[i - 1] * T(i);
g[m - 1] = f[m - 1].inverse();
h[m - 1] = g[m - 1] * f[m - 2];
for (int i = m - 2; i >= n; i--) {
g[i] = g[i + 1] * T(i + 1);
h[i] = g[i] * f[i - 1];
}
}
T fac(int i) {
if (i < 0) return T(0);
while (i >= (int)f.size()) extend();
return f[i];
}
T finv(int i) {
if (i < 0) return T(0);
while (i >= (int)g.size()) extend();
return g[i];
}
T inv(int i) {
if (i < 0) return -inv(-i);
while (i >= (int)h.size()) extend();
return h[i];
}
T C(int n, int r) {
if (n < 0 || n < r || r < 0) return T(0);
return fac(n) * finv(n - r) * finv(r);
}
inline T operator()(int n, int r) { return C(n, r); }
template <typename I>
T multinomial(const vector<I>& r) {
static_assert(is_integral<I>::value == true);
int n = 0;
for (auto& x : r) {
if(x < 0) return T(0);
n += x;
}
T res = fac(n);
for (auto& x : r) res *= finv(x);
return res;
}
template <typename I>
T operator()(const vector<I>& r) {
return multinomial(r);
}
T C_naive(int n, int r) {
if (n < 0 || n < r || r < 0) return T(0);
T ret = T(1);
r = min(r, n - r);
for (int i = 1; i <= r; ++i) ret *= inv(i) * (n--);
return ret;
}
T P(int n, int r) {
if (n < 0 || n < r || r < 0) return T(0);
return fac(n) * finv(n - r);
}
T H(int n, int r) {
if (n < 0 || r < 0) return T(0);
return r == 0 ? 1 : C(n + r - 1, r);
}
};
using mint = LazyMontgomeryModInt<998244353>;
// using mint = LazyMontgomeryModInt<1000000007>;
using vm = vector<mint>;
using vvm = vector<vm>;
Binomial<mint> C;
/*
#include "math/rational.hpp"
using mint=Rational;
using namespace Nyaan;
*/
namespace HashMapImpl {
using u32 = uint32_t;
using u64 = uint64_t;
template <typename Key, typename Data>
struct HashMapBase;
template <typename Key, typename Data>
struct itrB
: iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&> {
using base =
iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&>;
using ptr = typename base::pointer;
using ref = typename base::reference;
u32 i;
HashMapBase<Key, Data>* p;
explicit constexpr itrB() : i(0), p(nullptr) {}
explicit constexpr itrB(u32 _i, HashMapBase<Key, Data>* _p) : i(_i), p(_p) {}
explicit constexpr itrB(u32 _i, const HashMapBase<Key, Data>* _p)
: i(_i), p(const_cast<HashMapBase<Key, Data>*>(_p)) {}
friend void swap(itrB& l, itrB& r) { swap(l.i, r.i), swap(l.p, r.p); }
friend bool operator==(const itrB& l, const itrB& r) { return l.i == r.i; }
friend bool operator!=(const itrB& l, const itrB& r) { return l.i != r.i; }
const ref operator*() const {
return const_cast<const HashMapBase<Key, Data>*>(p)->data[i];
}
ref operator*() { return p->data[i]; }
ptr operator->() const { return &(p->data[i]); }
itrB& operator++() {
assert(i != p->cap && "itr::operator++()");
do {
i++;
if (i == p->cap) break;
if (p->flag[i] == true && p->dflag[i] == false) break;
} while (true);
return (*this);
}
itrB operator++(int) {
itrB it(*this);
++(*this);
return it;
}
itrB& operator--() {
do {
i--;
if (p->flag[i] == true && p->dflag[i] == false) break;
assert(i != 0 && "itr::operator--()");
} while (true);
return (*this);
}
itrB operator--(int) {
itrB it(*this);
--(*this);
return it;
}
};
template <typename Key, typename Data>
struct HashMapBase {
using u32 = uint32_t;
using u64 = uint64_t;
using iterator = itrB<Key, Data>;
using itr = iterator;
protected:
template <typename K>
inline u64 randomized(const K& key) const {
return u64(key) ^ r;
}
template <typename K,
enable_if_t<is_same<K, Key>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<K>::value, nullptr_t> = nullptr>
inline u32 inner_hash(const K& key) const {
return (randomized(key) * 11995408973635179863ULL) >> shift;
}
template <
typename K, enable_if_t<is_same<K, Key>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<decltype(K::first)>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<decltype(K::second)>::value, nullptr_t> = nullptr>
inline u32 inner_hash(const K& key) const {
u64 a = randomized(key.first), b = randomized(key.second);
a *= 11995408973635179863ULL;
b *= 10150724397891781847ULL;
return (a + b) >> shift;
}
template <typename K,
enable_if_t<is_same<K, Key>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<typename K::value_type>::value, nullptr_t> =
nullptr>
inline u32 inner_hash(const K& key) const {
static constexpr u64 mod = (1LL << 61) - 1;
static constexpr u64 base = 950699498548472943ULL;
u64 res = 0;
for (auto& elem : key) {
__uint128_t x = __uint128_t(res) * base + (randomized(elem) & mod);
res = (x & mod) + (x >> 61);
}
__uint128_t x = __uint128_t(res) * base;
res = (x & mod) + (x >> 61);
if (res >= mod) res -= mod;
return res >> (shift - 3);
}
template <typename D = Data,
enable_if_t<is_same<D, Key>::value, nullptr_t> = nullptr>
inline u32 hash(const D& dat) const {
return inner_hash(dat);
}
template <
typename D = Data,
enable_if_t<is_same<decltype(D::first), Key>::value, nullptr_t> = nullptr>
inline u32 hash(const D& dat) const {
return inner_hash(dat.first);
}
template <typename D = Data,
enable_if_t<is_same<D, Key>::value, nullptr_t> = nullptr>
inline Key dtok(const D& dat) const {
return dat;
}
template <
typename D = Data,
enable_if_t<is_same<decltype(D::first), Key>::value, nullptr_t> = nullptr>
inline Key dtok(const D& dat) const {
return dat.first;
}
void reallocate(u32 ncap) {
vector<Data> ndata(ncap);
vector<bool> nf(ncap);
shift = 64 - __lg(ncap);
for (u32 i = 0; i < cap; i++) {
if (flag[i] == true && dflag[i] == false) {
u32 h = hash(data[i]);
while (nf[h]) h = (h + 1) & (ncap - 1);
ndata[h] = move(data[i]);
nf[h] = true;
}
}
data.swap(ndata);
flag.swap(nf);
cap = ncap;
dflag.resize(cap);
fill(std::begin(dflag), std::end(dflag), false);
}
inline bool extend_rate(u32 x) const { return x * 2 >= cap; }
inline bool shrink_rate(u32 x) const {
return HASHMAP_DEFAULT_SIZE < cap && x * 10 <= cap;
}
inline void extend() { reallocate(cap << 1); }
inline void shrink() { reallocate(cap >> 1); }
public:
u32 cap, s;
vector<Data> data;
vector<bool> flag, dflag;
u32 shift;
static u64 r;
static constexpr uint32_t HASHMAP_DEFAULT_SIZE = 4;
explicit HashMapBase()
: cap(HASHMAP_DEFAULT_SIZE),
s(0),
data(cap),
flag(cap),
dflag(cap),
shift(64 - __lg(cap)) {}
itr begin() const {
u32 h = 0;
while (h != cap) {
if (flag[h] == true && dflag[h] == false) break;
h++;
}
return itr(h, this);
}
itr end() const { return itr(this->cap, this); }
friend itr begin(const HashMapBase& h) { return h.begin(); }
friend itr end(const HashMapBase& h) { return h.end(); }
itr find(const Key& key) const {
u32 h = inner_hash(key);
while (true) {
if (flag[h] == false) return this->end();
if (dtok(data[h]) == key) {
if (dflag[h] == true) return this->end();
return itr(h, this);
}
h = (h + 1) & (cap - 1);
}
}
bool contain(const Key& key) const { return find(key) != this->end(); }
itr insert(const Data& d) {
u32 h = hash(d);
while (true) {
if (flag[h] == false) {
if (extend_rate(s + 1)) {
extend();
h = hash(d);
continue;
}
data[h] = d;
flag[h] = true;
++s;
return itr(h, this);
}
if (dtok(data[h]) == dtok(d)) {
if (dflag[h] == true) {
data[h] = d;
dflag[h] = false;
++s;
}
return itr(h, this);
}
h = (h + 1) & (cap - 1);
}
}
// tips for speed up :
// if return value is unnecessary, make argument_2 false.
itr erase(itr it, bool get_next = true) {
if (it == this->end()) return this->end();
s--;
if (shrink_rate(s)) {
Data d = data[it.i];
shrink();
it = find(dtok(d));
}
int ni = (it.i + 1) & (cap - 1);
if (this->flag[ni]) {
this->dflag[it.i] = true;
} else {
this->flag[it.i] = false;
}
if (get_next) ++it;
return it;
}
itr erase(const Key& key) { return erase(find(key)); }
bool empty() const { return s == 0; }
int size() const { return s; }
void clear() {
fill(std::begin(flag), std::end(flag), false);
fill(std::begin(dflag), std::end(dflag), false);
s = 0;
}
void reserve(int n) {
if (n <= 0) return;
n = 1 << min(23, __lg(n) + 2);
if (cap < u32(n)) reallocate(n);
}
};
template <typename Key, typename Data>
uint64_t HashMapBase<Key, Data>::r =
chrono::duration_cast<chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count();
} // namespace HashMapImpl
/**
* @brief Hash Map(base) (ハッシュマップ・基底クラス)
*/
template <typename Key, typename Val>
struct HashMap : HashMapImpl::HashMapBase<Key, pair<Key, Val>> {
using base = typename HashMapImpl::HashMapBase<Key, pair<Key, Val>>;
using HashMapImpl::HashMapBase<Key, pair<Key, Val>>::HashMapBase;
using Data = pair<Key, Val>;
Val& operator[](const Key& k) {
typename base::u32 h = base::inner_hash(k);
while (true) {
if (base::flag[h] == false) {
if (base::extend_rate(base::s + 1)) {
base::extend();
h = base::hash(k);
continue;
}
base::data[h].first = k;
base::data[h].second = Val();
base::flag[h] = true;
++base::s;
return base::data[h].second;
}
if (base::data[h].first == k) {
if (base::dflag[h] == true) base::data[h].second = Val();
return base::data[h].second;
}
h = (h + 1) & (base::cap - 1);
}
}
typename base::itr emplace(const Key& key, const Val& val) {
return base::insert(Data(key, val));
}
};
/*
* @brief ハッシュマップ(連想配列)
* @docs docs/hashmap/hashmap.md
**/
vector<mint> LinearEquation_hashmap(const vector<vector<mint>>& a,
vector<mint> b) {
int H = a.size(), W = a[0].size();
vector<HashMap<int, mint>> A(H);
rep(i, H) rep(j, W) if (a[i][j] != 0) A[i][j] = a[i][j];
vector<int> pivots(W);
int rank = 0, je = W;
for (int j = 0; j < je; j++) {
trc(j);
int idx = -1;
for (int i = rank; i < H; i++) {
auto it = A[i].find(j);
if (it != end(A[i]) and it->second != mint{}) {
idx = i;
break;
}
}
pivots[j] = idx;
if (idx == -1) continue;
if (rank != idx) {
swap(A[rank], A[idx]);
swap(b[rank], b[idx]);
}
if (a[rank][j] != mint(1)) {
mint coeff = A[rank][j].inverse();
for (auto& [k, v] : A[rank]) {
if (v != mint{}) v *= coeff;
}
b[rank] *= coeff;
}
vector<pair<int, mint>> arank;
for (auto& [k, v] : A[rank]) {
if (v != mint{}) arank.emplace_back(k, v);
}
for (int i = 0; i < H; i++) {
if (i == rank) continue;
auto it = A[i].find(j);
if (it != end(A[i]) and it->second != mint{}) {
mint coeff = (it->second);
for (auto& [k, v] : arank) A[i][k] -= v * coeff;
b[i] -= b[rank] * coeff;
}
}
rank++;
}
vector<mint> res(W);
for (int j = 0; j < W; j++) {
if (pivots[j] != -1) res[j] = b[j];
}
return res;
}
void Nyaan::solve() {
inl(N);
map<int, int> ws;
Edges<ll> es;
rep(i, N - 1) {
inl(u, v, w);
--u, --v;
es.emplace_back(u, v, w);
ws[w]++;
}
int X = 0, Y = 0;
mint a = 0, b = 0;
tie(a, X) = *begin(ws);
if (sz(ws) == 2) tie(b, Y) = *next(begin(ws));
vector<vector<mint>> A((X + 1) * (Y + 1) - 1,
vector((X + 1) * (Y + 1), mint{}));
vector<mint> B((X + 1) * (Y + 1));
auto id = [&](int i, int j) { return i * (Y + 1) + j; };
rep(i, X + 1) rep(j, Y + 1) {
if (i == X and j == Y) continue;
mint p = N * (N - 1) / 2 - (X + Y - 1);
mint q = N - i - j;
if (i != 0) A[id(i, j)][id(i - 0, j)] += a * i * q;
if (i != 0) A[id(i, j)][id(i - 1, j)] += a * i * (p - q);
if (j != 0) A[id(i, j)][id(i, j - 0)] += b * j * q;
if (j != 0) A[id(i, j)][id(i, j - 1)] += b * j * (p - q);
if (i != X) A[id(i, j)][id(i + 0, j)] += a * (X - i) * (p - q + 1);
if (i != X) A[id(i, j)][id(i + 1, j)] += a * (X - i) * (q - 1);
if (j != Y) A[id(i, j)][id(i, j + 0)] += b * (Y - j) * (p - q + 1);
if (j != Y) A[id(i, j)][id(i, j + 1)] += b * (Y - j) * (q - 1);
mint all = (a * X + b * Y) * p;
A[id(i, j)][id(i, j)] -= all;
B[id(i, j)] = -all / N;
}
auto xs = LinearEquation_hashmap(A, B);
trc(LinearEquation(A, B));
rep(i, X + 1) rep(j, Y + 1) { trc(i, j, xs[id(i, j)]); }
vi cx(N), cy(N);
each(e, es) {
(a == e.cost ? cx : cy)[e.src]++;
(a == e.cost ? cx : cy)[e.to]++;
}
trc(cx, cy);
mint ans = 0;
rep(i, N) ans += xs[id(cx[i], cy[i])];
ans -= xs[id(1, 0)] * X + xs[id(0, 1)] * Y + xs[id(X, Y)];
out(ans);
}