Language: C++

#include <bits/stdc++.h>
#define N 100005

using namespace std;
typedef long long ll;

template <class T> inline void read(T &x) {
	char ch; bool flag = false;
	while (!isdigit(ch = getchar())) flag |= ch == '-';
	for (x = ch ^ 48; isdigit(ch = getchar()); x = x * 10 + (ch ^ 48));
	if (flag) x = -x;
}

inline int input() {
	int x; char ch; bool flag = false;
	while (!isdigit(ch = getchar())) flag |= ch == '-';
	for (x = ch ^ 48; isdigit(ch = getchar()); x = x * 10 + (ch ^ 48));
	return flag ? -x : x;
}

const int mod = 1e9 + 7;
inline int add(int x, int y) { x += y; return x >= mod ? x - mod : x; }
inline void inc(int &x, int y) { x += y; x -= x >= mod ? mod : 0; }

inline int Power(int x, int y) {
	int res = 1;
	while (y) {
		if (y & 1) res = (ll) res * x % mod;
		x = (ll) x * x % mod, y >>= 1;
	} return res;
}

template <class T> void chkmax(T &x, T y) { x = x > y ? x : y; }
template <class T> void chkmin(T &x, T y) { x = x < y ? x : y; }
template <class T> T gcd(T x, T y) { return !y ? x : gcd(x % y, y); }

int n;
int p[N];
vector<int> G[N];
int depth[N], size[N], fa[N], res, s;
int ansa[N], ansb[N], tot, index;

inline void AddEdge(int x, int y) {
	G[x].push_back(y);
	G[y].push_back(x);
}

void dfs(int u) {
	size[u] = 1;
	depth[u] = depth[fa[u]] + 1;
	if (depth[u] > depth[res]) res = u;
	for (int v : G[u]) {
		if (v == fa[u]) continue;
		fa[v] = u, dfs(v), size[u] += size[v];
	}
}

bool check() {
	for (int i = 1; i <= n; ++i) {
		int tmp = 0;
		for (int v : G[i]) {
			if (v == fa[i]) continue;
			if (size[v] != 1) ++tmp;
		}
		if (tmp > 1) return false;
	} return true;
}

void solvea(int u) {
	int son = 0, idu = ++index;
	sort(G[u].begin(), G[u].end());
	for (int v : G[u]) {
		if (v == fa[u]) continue;
		if (size[v] != 1) son = v;
		else ansa[++tot] = ++index;
	}
	ansa[++tot] = idu;
	if (son) solvea(son);
	else swap(ansa[tot], ansa[tot - 1]);
}

void solveb(int u) {
	int son = 0, idu = ++index;
	sort(G[u].begin(), G[u].end());
	for (int v : G[u]) {
		if (v == fa[u]) continue;
		if (size[v] != 1) son = v;
		else ansb[++tot] = ++index;
	}
	ansb[++tot] = idu;
	if (son) solveb(son);
	else swap(ansb[tot], ansb[tot - 1]);
}

int main() {
	ios::sync_with_stdio(false);
	cin >> n;
	for (int i = 1; i < n; ++i) {
		int x, y;
		cin >> x >> y;
		AddEdge(x, y);
	}

	dfs(1), s = res, fa[res] = 0, dfs(res);
	if (!check()) return puts("-1"), 0;
	solvea(s), index = tot = 0;
	s = res, fa[res] = 0, dfs(res);
	solveb(s);
	
	int *ans = ansa;
	for (int i = 1; i <= tot; ++i) {
		if (ansa[i] < ansb[i]) {
			ans = ansa;
			break;
		} else if (ansa[i] > ansb[i]) {
			ans = ansb;
			break;
		}
	}
	for (int i = 1; i < tot; ++i) printf("%d ", ans[i]);
	printf("%d\n", ans[tot]);
	return 0;
}

Compiler output:
a.cc:41:28: error: 'int index' redeclared as different kind of entity
   41 | int ansa[N], ansb[N], tot, index;
      |                            ^~~~~
In file included from /usr/include/string.h:462,
                 from /usr/include/c++/14/cstring:43,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:121,
                 from a.cc:1:
/usr/include/strings.h:50:20: note: previous declaration 'const char* index(const char*, int)'
   50 | extern const char *index (const char *__s, int __c)
      |                    ^~~~~
a.cc: In function 'void dfs(int)':
a.cc:49:9: error: reference to 'size' is ambiguous
   49 |         size[u] = 1;
      |         ^~~~
In file included from /usr/include/c++/14/string:53,
                 from /usr/include/c++/14/bitset:52,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:52:
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
  272 |     size(const _Tp (&)[_Nm]) noexcept
      |     ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note:                 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
  262 |     size(const _Container& __cont) noexcept(noexcept(__cont.size()))
      |     ^~~~
a.cc:40:15: note:                 'int size [100005]'
   40 | int depth[N], size[N], fa[N], res, s;
      |               ^~~~
a.cc:54:36: error: reference to 'size' is ambiguous
   54 |                 fa[v] = u, dfs(v), size[u] += size[v];
      |                                    ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
  272 |     size(const _Tp (&)[_Nm]) noexcept
      |     ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note:                 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
  262 |     size(const _Container& __cont) noexcept(noexcept(__cont.size()))
      |     ^~~~
a.cc:40:15: note:                 'int size [100005]'
   40 | int depth[N], size[N], fa[N], res, s;
      |               ^~~~
a.cc:54:47: error: reference to 'size' is ambiguous
   54 |                 fa[v] = u, dfs(v), size[u] += size[v];
      |                                               ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
  272 |     size(const _Tp (&)[_Nm]) noexcept
      |     ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note:                 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
  262 |     size(const _Container& __cont) noexcept(noexcept(__cont.size()))
      |     ^~~~
a.cc:40:15: note:                 'int size [100005]'
   40 | int depth[N], size[N], fa[N], res, s;
      |               ^~~~
a.cc: In function 'bool check()':
a.cc:63:29: error: reference to 'size' is ambiguous
   63 |                         if (size[v] != 1) ++tmp;
      |                             ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
  272 |     size(const _Tp (&)[_Nm]) noexcept
      |     ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note:                 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
  262 |     size(const _Container& __cont) noexcept(noexcept(__cont.size()))
      |     ^~~~
a.cc:40:15: note:                 'int size [100005]'
   40 | int depth[N], size[N], fa[N], res, s;
      |               ^~~~
a.cc: In function 'void solvea(int)':
a.cc:70:30: error: no pre-increment operator for type
   70 |         int son = 0, idu = ++index;
      |                              ^~~~~
a.cc:74:21: error: reference to 'size' is ambiguous
   74 |                 if (size[v] != 1) son = v;
      |                     ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
  272 |     size(const _Tp (&)[_Nm]) noexcept
      |     ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note:                 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
  262 |     size(const _Container& __cont) noexcept(noexcept(__cont.size()))
      |     ^~~~
a.cc:40:15: note:                 'int size [100005]'
   40 | int depth[N], size[N], fa[N], res, s;
      |               ^~~~
a.cc:75:38: error: no pre-increment operator for type
   75 |                 else ansa[++tot] = ++index;
      |                                      ^~~~~
a.cc: In function 'void solveb(int)':
a.cc:83:30: error: no pre-increment operator for type
   83 |         int son = 0, idu = ++index;
      |                              ^~~~~
a.cc:87:21: error: reference to 'size' is ambiguous
   87 |                 if (size[v] != 1) son = v;
      |                     ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
  272 |     size(const _Tp (&)[_Nm]) noexcept
      |     ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note:                 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
  262 |     size(const _Container& __cont) noexcept(noexcept(__cont.size()))
      |     ^~~~
a.cc:40:15: note:                 'int size [100005]'
   40 | int depth[N], size[N], fa[N], res, s;
      |               ^~~~
a.cc:88:38: error: no pre-increment operator for type
   88 |                 else ansb[++tot] = ++index;
      |                                      ^~~~~
a.cc: In function 'int main()':
a.cc:106:34: error: overloaded function with no contextual type information
  106 |         solvea(s), index = tot = 0;
      |                                  ^