#include #include template struct is_dereferenceable : std::false_type {}; template struct is_dereferenceable())>> : std::true_type {}; template struct is_iterable : std::false_type {}; template struct is_iterable())), decltype(std::end(std::declval()))>> : std::true_type {}; template struct is_applicable : std::false_type {}; template struct is_applicable::value)>> : std::true_type {}; template void debug(const T& value, const Ts&... args); template void debug(const T& v) { if constexpr (is_dereferenceable::value) { std::cerr << "{"; if (v) { debug(*v); } else { std::cerr << "nil"; } std::cerr << "}"; } else if constexpr (is_iterable::value && !std::is_same::value) { std::cerr << "{"; for (auto it = std::begin(v); it != std::end(v); ++it) { if (it != std::begin(v)) std::cerr << ", "; debug(*it); } std::cerr << "}"; } else if constexpr (is_applicable::value) { std::cerr << "{"; std::apply([](const auto&... args) { debug(args...); }, v); std::cerr << "}"; } else { std::cerr << v; } } template void debug(const T& value, const Ts&... args) { debug(value); std::cerr << ", "; debug(args...); } #if DEBUG #define dbg(...) \ do { \ cerr << #__VA_ARGS__ << ": "; \ debug(__VA_ARGS__); \ cerr << " (L" << __LINE__ << ")\n"; \ } while (0) #else #define dbg(...) #endif void read_from_cin() {} template void read_from_cin(T& value, Ts&... args) { std::cin >> value; read_from_cin(args...); } #define rd(type, ...) \ type __VA_ARGS__; \ read_from_cin(__VA_ARGS__); #define ints(...) rd(int, __VA_ARGS__); #define strings(...) rd(string, __VA_ARGS__); template void write_to_cout(const T& value) { if constexpr (std::is_same::value) { std::cout << (value ? "Yes" : "No"); } else { std::cout << value; } } template void write_to_cout(const T& value, const Ts&... args) { write_to_cout(value); std::cout << ' '; write_to_cout(args...); } #define wt(...) \ do { \ write_to_cout(__VA_ARGS__); \ cout << '\n'; \ } while (0) #define all(x) (x).begin(), (x).end() #define eb(...) emplace_back(__VA_ARGS__) #define pb(...) push_back(__VA_ARGS__) #define dispatch(_1, _2, _3, name, ...) name #define as_i64(x) \ ( \ [] { \ static_assert( \ std::is_integral< \ typename std::remove_reference::type>::value, \ "rep macro supports std integral types only"); \ }, \ static_cast(x)) #define rep3(i, a, b) for (std::int64_t i = as_i64(a); i < as_i64(b); ++i) #define rep2(i, n) rep3(i, 0, n) #define rep1(n) rep2(_loop_variable_, n) #define rep(...) dispatch(__VA_ARGS__, rep3, rep2, rep1)(__VA_ARGS__) #define rrep3(i, a, b) for (std::int64_t i = as_i64(b) - 1; i >= as_i64(a); --i) #define rrep2(i, n) rrep3(i, 0, n) #define rrep1(n) rrep2(_loop_variable_, n) #define rrep(...) dispatch(__VA_ARGS__, rrep3, rrep2, rrep1)(__VA_ARGS__) #define each3(k, v, c) for (auto&& [k, v] : c) #define each2(e, c) for (auto&& e : c) #define each(...) dispatch(__VA_ARGS__, each3, each2)(__VA_ARGS__) template std::istream& operator>>(std::istream& is, std::vector& v) { for (T& vi : v) is >> vi; return is; } template std::istream& operator>>(std::istream& is, std::pair& p) { is >> p.first >> p.second; return is; } template bool chmax(T& a, U b) { if (a < b) { a = b; return true; } return false; } template bool chmin(T& a, U b) { if (a > b) { a = b; return true; } return false; } template auto max(T a, U b) { return a > b ? a : b; } template auto min(T a, U b) { return a < b ? a : b; } template int sz(const T& v) { return v.size(); } template int popcount(T i) { return std::bitset::digits>(i).count(); } template bool hasbit(T s, int i) { return std::bitset::digits>(s)[i]; } template auto div_ceil(T n, U d) { return (n + d - 1) / d; } template bool even(T x) { return x % 2 == 0; } const std::int64_t big = std::numeric_limits::max() / 10; using i64 = std::int64_t; using i32 = std::int32_t; template using low_priority_queue = std::priority_queue, std::greater>; template using V = std::vector; template using VV = V>; void Main(); int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(NULL); std::cout << std::fixed << std::setprecision(20); Main(); return 0; } const auto& Fix = boost::hana::fix; using namespace std; #define int i64 #pragma once template class BidirectedGraph { public: struct Edge { int from, to; T weight; Edge* back = nullptr; Edge(int from, int to, T weight = T()) : from(from), to(to), weight(weight) {} }; BidirectedGraph(int n) : edges_(n) {} std::pair AddEdge(int from, int to, T weight = T()) { Edge& forward = AddDirectedEdge(from, to, weight); Edge& back = AddDirectedEdge(to, from, weight); forward.back = &back; back.back = &forward; return {forward, back}; } const std::vector>& Edges(int from) const { return edges_[from]; } std::vector>& MutableEdges(int from) { return edges_[from]; } int NumVertices() const { return edges_.size(); } private: Edge& AddDirectedEdge(int from, int to, T weight = T()) { edges_[from].push_back(std::make_unique(from, to, weight)); return *edges_[from].back(); } std::vector>> edges_; }; #define BIN_OPS(F) F(+) F(-) F(*) F(/) #define CMP_OPS(F) F(!=) F(<) F(<=) F(==) F(>) F(>=) template class ModInt { public: ModInt() : n_(0) {} ModInt(long long n) : n_(n % Mod) { if (n_ < 0) { // In C++, (-n)%m == -(n%m). n_ += Mod; } } ModInt& operator+=(const ModInt& m) { n_ += m.n_; if (n_ >= Mod) { n_ -= Mod; } return *this; } ModInt& operator++() { return (*this) += 1; } ModInt& operator-=(const ModInt& m) { n_ -= m.n_; if (n_ < 0) { n_ += Mod; } return *this; } ModInt& operator--() { return (*this) -= 1; } ModInt& operator*=(const ModInt& m) { n_ *= m.n_; n_ %= Mod; return *this; } ModInt& operator/=(const ModInt& m) { *this *= m.Inv(); return *this; } #define DEFINE(op) \ ModInt operator op(const ModInt& m) const { return ModInt(*this) op## = m; } BIN_OPS(DEFINE) #undef DEFINE #define DEFINE(op) \ bool operator op(const ModInt& m) const { return n_ op m.n_; } CMP_OPS(DEFINE) #undef DEFINE ModInt operator-() const { return ModInt(-n_); } ModInt Pow(int n) const { if (n < 0) { return Inv().Pow(-n); } // a * b ^ n = answer. ModInt a = 1, b = *this; while (n != 0) { if (n & 1) { a *= b; } n /= 2; b *= b; } return a; } ModInt Inv() const { // Compute the inverse based on Fermat's little theorem. Note that this only // works when n_ and Mod are relatively prime. The theorem says that // n_^(Mod-1) = 1 (mod Mod). So we can compute n_^(Mod-2). return Pow(Mod - 2); } long long value() const { return n_; } static ModInt Fact(int n) { for (int i = fact_.size(); i <= n; ++i) { fact_.push_back(i == 0 ? 1 : fact_.back() * i); } return fact_[n]; } static ModInt Comb(int n, int k) { return Perm(n, k) / Fact(k); } static ModInt CombSlow(int n, int k) { return PermSlow(n, k) / Fact(k); } static ModInt Perm(int n, int k) { #if DEBUG assert(n <= 1000000 && "n is too large. If k is small, consider using PermSlow."); #endif return Fact(n) / Fact(n - k); } static ModInt PermSlow(int n, int k) { ModInt p = 1; for (int i = 0; i < k; ++i) { p *= (n - i); } return p; } private: long long n_; inline static std::vector fact_; }; #define DEFINE(op) \ template \ ModInt operator op(const T& t, const ModInt& m) { \ return ModInt(t) op m; \ } BIN_OPS(DEFINE) CMP_OPS(DEFINE) #undef DEFINE template std::ostream& operator<<(std::ostream& out, const ModInt& m) { out << m.value(); return out; } namespace pclib { namespace internal { template class DP { using Edge = typename BidirectedGraph::Edge; struct Weight { Edge* edge; T result; }; using MetaEdge = typename BidirectedGraph::Edge; public: DP(const BidirectedGraph& graph, std::function op2, std::function op1, T identity = T()) : graph_(graph.NumVertices()), op2_(op2), op1_(op1), identity_(identity) { for (int i = 0; i < graph.NumVertices(); ++i) { for (const auto& e : graph.Edges(i)) { if (e->from > e->to) continue; auto [f, b] = graph_.AddEdge(e->from, e->to); f.weight.edge = e.get(); b.weight.edge = e->back; } } } void Dfs(int root) { // Use a stack to avoid potential stack overflows. std::stack> s; s.emplace(nullptr, true); while (!s.empty()) { auto [in_edge, enter] = s.top(); s.pop(); int node = in_edge ? in_edge->to : root; if (enter) { s.emplace(in_edge, false); for (const auto& e : graph_.Edges(node)) { if (e->back != in_edge) { s.emplace(e.get(), true); } } } else { T t = identity_; for (const auto& e : graph_.Edges(node)) { if (e->back != in_edge) { t = op2_(t, e->weight.result); } } if (in_edge) { in_edge->weight.result = op1_(*in_edge->weight.edge, t); } } } } std::vector Rerooting(int root) { std::vector result(graph_.NumVertices()); std::stack> s; s.emplace(nullptr, identity_); while (!s.empty()) { auto [in_edge, in_result] = s.top(); s.pop(); if (in_edge) { in_edge->back->weight.result = in_result; } int node = in_edge ? in_edge->to : root; const auto& edges = graph_.Edges(node); // lower[i] = op2_(dp[i - 1], op2_(dp[i - 2], ...)) std::vector lower(edges.size() + 1); lower[0] = identity_; for (std::size_t i = 0; i < edges.size(); ++i) { lower[i + 1] = op2_(lower[i], edges[i]->weight.result); } // higher[i] = op2_(dp[i], op2_(dp[i + 1], ...)) std::vector higher(edges.size() + 1); higher[edges.size()] = identity_; for (std::size_t i = edges.size() - 1; i < edges.size(); --i) { higher[i] = op2_(higher[i + 1], edges[i]->weight.result); } result[node] = higher[0]; for (std::size_t i = 0; i < edges.size(); ++i) { if (const auto& e = edges[i]; e->back != in_edge) { s.emplace(e.get(), op1_(*e->back->weight.edge, op2_(lower[i], higher[i + 1]))); } } } return result; } BidirectedGraph graph_; const std::function op2_; const std::function op1_; const T identity_; }; } // namespace internal } // namespace pclib template std::vector Rerooting( const BidirectedGraph& graph, std::function op2, std::function::Edge&, T)> op1, T identity = T()) { pclib::internal::DP dp(graph, op2, op1, identity); dp.Dfs(0); return dp.Rerooting(0); } void Main() { ints(n); BidirectedGraph g(n); rep(n - 1) { ints(a, b); g.AddEdge(a - 1, b - 1); } // Tree: 1 -> 2 -> 3 // // N3 = {0} = ID // E2->3 = {0, 1} = {0} + inc({0}) = f(ID) // N2 = {0, 1} = {0, 1} x ID // E1->2 = {0, 0, 1, 2} = {0, 0} + inc({0, 1}) // N1 = {0, 0, 1, 2} // // Tree: 3 <- 1 -> 2 // // N2 = {0} // N3 = {0} // E1-2 = {0, 1} = {0} + inc({0}) // E1-3 = {0, 1} = {0} + inc({0}) // N1 = {0, 1, 1, 2} = {0, 1} x {0, 1} using mint = ModInt<>; struct DP { mint sqsum, sum, cnt; }; auto f = [](DP x) -> DP { return {x.sqsum + 2 * x.sum + x.cnt, x.sum + x.cnt, x.cnt * 2}; }; V res = Rerooting( g, [](DP a, DP b) -> DP { return {a.sqsum * b.cnt + 2 * a.sum * b.sum + b.sqsum * a.cnt, a.sum * b.cnt + b.sum * a.cnt, a.cnt * b.cnt}; }, [&](const auto&, DP x) -> DP { return f(x); }, {0, 0, 1}); mint ans = 0; each(r, res) ans += f(r).sqsum; wt(ans); }