Language: C++

#include<bits/stdc++.h>
#define MOD 1000000007
// #define MOD 998244353

class mint {
	public:
		int i;

		mint() : i(0) {}

		template<class T>
			mint(T x) {
				i = int(x % MOD);
				if (i < 0) i += MOD;
			}

		mint operator+(mint x) {
			return i + x.i;
		}

		mint operator-(mint x) {
			return i - x.i;
		}

		mint operator*(mint x) {
			return (long long)i * x.i;
		}

		mint operator/(mint x) {
			return (long long)i * x.pow(MOD - 2).i;
		}

		mint inv() {
			return pow(MOD - 2);
		}

		template<class T>
			mint pow(T p) {
				long long r = 1;
				long long t = i;
				for(; p > 0; p >>= 1) {
					if (p & 1) r = r * t % MOD;
					t = t * t % MOD;
				}
				return r;
			}

		template<class T1, class T2>
			static mint pow(T1 a, T2 b) {
				long long r = 1;
				long long t = (long long)(a % MOD);
				for(; b > 0; b >>= 1) {
					if (b & 1) r = r * t % MOD;
					t = t * t % MOD;
				}
				return r;
			}

		mint& operator+=(mint x) {
			i = (i + x.i) % MOD;
			return *this;
		}

		mint& operator-=(mint x) {
			i = i - x.i;
			if (i < 0) i += MOD;
			return *this;
		}

		mint& operator*=(mint x) {
			i = (int)((long long)i * x.i % MOD);
			return *this;
		}

		mint& operator/=(mint x) {
			i = (long long)i * x.pow(MOD - 2).i % MOD;
			return *this;
		}
};

std::ostream& operator<<(std::ostream& os, const mint& m) {
	return os << m.i;
}

struct combination {
  vector<mint> fact, ifact;
  combination(int n):fact(n+1),ifact(n+1) {
    assert(n < mod);
    fact[0] = 1;
    for (int i = 1; i <= n; ++i) fact[i] = fact[i-1]*i;
    ifact[n] = fact[n].inv();
    for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i]*i;
  }
  mint operator()(int n, int k) {
    if (k < 0 || k > n) return 0;
    return fact[n]*ifact[k]*ifact[n-k];
  }
} mcomb(200002);

// T has to implement 'operator+' and 'add_parent' method
template<class T>
class rtdp {
	class Node {
		public:
		int k; // k_th node
		rtdp& nodes; // owner object holding all nodes
		const std::vector<int>& children; // children indices
		const int csize;
		std::vector<T> dp; // stores dps of children
		std::vector<T> lmerged;
		std::vector<T> rmerged;

		Node(rtdp& ns, int i) : k(i), nodes(ns), children(ns.v[i]), csize(children.size()), dp(csize), lmerged(csize + 1), rmerged(csize + 1) {}

		T fc(int parent = -1) {
			const int csize = children.size();
			T m;
			for(int i = 0; i < csize; i++) {
				int ci = children[i];
				if (ci == parent) continue;
				dp[i] = nodes.ns[ci].fc(k);
				m = m + dp[i];
			}
			return m.add_parent(k);
		}

		void fp(int parent = -1) {
			const int csize = children.size();
			// assume that dp is already filled in
			// left merge
			for(int i = 0; i < csize; i++) {
				lmerged[i + 1] = lmerged[i] + dp[i];
			}
			// right merge
			for(int i = csize; i > 0; i--) {
				rmerged[i - 1] = rmerged[i] + dp[i - 1];
			}
			for(int i = 0; i < csize; i++) {
				int  ci = children[i];
				if (ci == parent) continue;
				Node& cnode = nodes.ns[ci];
				for(int j = 0; j < cnode.csize; j++) {
					if (cnode.children[j] == k) {
						cnode.dp[j] = (lmerged[i] + rmerged[i + 1]).add_parent(k);
						break;
					}
				}
				cnode.fp(k);
			}
			return;
		}
	};

	std::vector<std::vector<int>>& v;
	int size;
	std::vector<Node> ns;
	std::vector<T> root_dp;

	public:
	rtdp(std::vector<std::vector<int>>& v) : v(v), size(v.size()), root_dp(size) {
		for(int i = 0; i < size; i++) {
			ns.push_back(Node(*this, i));
		}
	}

	void exec_dp(int root = 0) {
		fill_in_children(root);
		fill_in_parent(root);
	}

	void fill_in_children(int root) {
		ns[root].fc();
	}

	void fill_in_parent(int root) {
		ns[root].fp();
	}

	T get_root_dp(int i) {
		Node& r = ns[i];
		return r.lmerged[r.csize].add_parent(i);
	}

};


struct DP {
	int tsize;
	mint count;

	DP(int s = 0, mint c = 1): tsize(s), count(c) {}

	DP operator+(DP d) {
		int tot_tsize = tsize + d.tsize;
		mint tot_count = count * d.count * mcomb(tot_tsize, d.tsize);
		return DP(tot_tsize, tot_count);
	}

	DP add_parent(int k) {
		return DP(tsize + 1, count);
	}
};

int main() {
	int n;
	std::cin >> n;
	std::vector<std::vector<int>> v(n);
	for(int i = 0; i < n - 1; i++) {
		int a, b;
		std::cin >> a >> b;
		a--; b--;
		v[a].push_back(b);
		v[b].push_back(a);
	}
	rtdp<DP> r(v);
	r.exec_dp();
	for(int i = 0; i < n; i++) {
		std::cout << r.get_root_dp(i).count << std::endl;
	}
}



Compiler output:
a.cc:86:3: error: 'vector' does not name a type
   86 |   vector<mint> fact, ifact;
      |   ^~~~~~
a.cc: In constructor 'combination::combination(int)':
a.cc:87:22: error: class 'combination' does not have any field named 'fact'
   87 |   combination(int n):fact(n+1),ifact(n+1) {
      |                      ^~~~
a.cc:87:32: error: class 'combination' does not have any field named 'ifact'
   87 |   combination(int n):fact(n+1),ifact(n+1) {
      |                                ^~~~~
In file included from /usr/include/c++/14/cassert:44,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:106,
                 from a.cc:1:
a.cc:88:16: error: 'mod' was not declared in this scope; did you mean 'modf'?
   88 |     assert(n < mod);
      |                ^~~
a.cc:89:5: error: 'fact' was not declared in this scope
   89 |     fact[0] = 1;
      |     ^~~~
a.cc:91:5: error: 'ifact' was not declared in this scope
   91 |     ifact[n] = fact[n].inv();
      |     ^~~~~
a.cc: In member function 'mint combination::operator()(int, int)':
a.cc:96:12: error: 'fact' was not declared in this scope
   96 |     return fact[n]*ifact[k]*ifact[n-k];
      |            ^~~~
a.cc:96:20: error: 'ifact' was not declared in this scope
   96 |     return fact[n]*ifact[k]*ifact[n-k];
      |                    ^~~~~