Problem:
Score : 900 points

Problem Statement

Takahashi has decided to make a Christmas Tree for the Christmas party in AtCoder, Inc.

A Christmas Tree is a tree with N vertices numbered 1 through N and N-1 edges, whose i-th edge (1\leq i\leq N-1) connects Vertex a_i and b_i.

He would like to make one as follows:

Specify two non-negative integers A and B.

Prepare A Christmas Paths whose lengths are at most B. Here, a Christmas Path of length X is a graph with X+1 vertices and X edges such that, if we properly number the vertices 1 through X+1, the i-th edge (1\leq i\leq X) will connect Vertex i and i+1.

Repeat the following operation until he has one connected tree:

Select two vertices x and y that belong to different connected components. Combine x and y into one vertex. More precisely, for each edge (p,y) incident to the vertex y, add the edge (p,x). Then, delete the vertex y and all the edges incident to y.

Properly number the vertices in the tree.

Takahashi would like to find the lexicographically smallest pair (A,B) such that he can make a Christmas Tree, that is, find the smallest A, and find the smallest B under the condition that A is minimized.

Solve this problem for him.

Constraints

2 \leq N \leq 10^5

1 \leq a_i,b_i \leq N

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
a_1 b_1
:
a_{N-1} b_{N-1}

Output

For the lexicographically smallest (A,B), print A and B with a space in between.

Sample Input 1

7
1 2
2 3
2 4
4 5
4 6
6 7

Sample Output 1

3 2

We can make a Christmas Tree as shown in the figure below:

Sample Input 2

8
1 2
2 3
3 4
4 5
5 6
5 7
5 8

Sample Output 2

2 5

Sample Input 3

10
1 2
2 3
3 4
2 5
6 5
6 7
7 8
5 9
10 5

Sample Output 3

3 4

Solution in C (GCC 9.2.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>

#define N	100000

unsigned int X;

void srand_() {
	struct timeval tv;

	gettimeofday(&tv, NULL);
	X = tv.tv_sec ^ tv.tv_usec;
}

int rand_() {
	return (X *= 3) >> 1;
}

int *oj[N], oo[N];

void link(int i, int j) {
	int o = oo[i]++;

	if (o >= 2 && (o & o - 1) == 0)
		oj[i] = (int *) realloc(oj[i], o * 2 * sizeof *oj[i]);
	oj[i][o] = j;
}

void sort(int *aa, int l, int r) {
	while (l < r) {
		int i = l, j = l, k = r, a = aa[l + rand_() % (r - l)], tmp;

		while (j < k)
			if (aa[j] == a)
				j++;
			else if (aa[j] < a) {
				tmp = aa[i], aa[i] = aa[j], aa[j] = tmp;
				i++, j++;
			} else {
				k--;
				tmp = aa[j], aa[j] = aa[k], aa[k] = tmp;
			}
		sort(aa, l, i);
		l = k;
	}
}

int solve(int *aa, int n, int i_, int l) {
	int i = 0, j = n - 1;

	while (i < j)
		if (i == i_)
			i++;
		else if (j == i_)
			j--;
		else {
			if (aa[i] + aa[j] > l)
				return 0;
			i++, j--;
		}
	return 1;
}

int dp[N];

int dfs(int p, int i, int l) {
	static int aa[N];
	int o, n, lower, upper;

	for (o = 0; o < oo[i]; o++) {
		int j = oj[i][o];

		if (j != p && !dfs(i, j, l))
			return 0;
	}
	n = 0;
	for (o = 0; o < oo[i]; o++) {
		int j = oj[i][o];

		if (j != p)
			aa[n++] = dp[j] + 1;
	}
	sort(aa, 0, n);
	if (p == -1)
		return solve(aa, n % 2 == 0 ? n : n - 1, -1, l);
	lower = n % 2 == 0 ? -2 : -1, upper = n;
	while (upper - lower > 1) {
		int h = (lower + upper) / 2;

		if (solve(aa, n, h, l))
			upper = h;
		else
			lower = h;
	}
	return upper < n && (dp[i] = upper == -1 ? 0 : aa[upper]) < l;
}

int main() {
	int n, h, i, j, k, lower, upper;

	srand_();
	scanf("%d", &n);
	for (i = 0; i < n; i++)
		oj[i] = (int *) malloc(2 * sizeof *oj[i]);
	for (h = 0; h < n - 1; h++) {
		scanf("%d%d", &i, &j), i--, j--;
		link(i, j), link(j, i);
	}
	k = n - 1;
	for (i = 0; i < n; i++)
		k -= oo[i] / 2;
	lower = 0, upper = n - 1;
	while (upper - lower > 1) {
		int l = (lower + upper) / 2;

		if (dfs(-1, 0, l))
			upper = l;
		else
			lower = l;
	}
	printf("%d %d\n", k, upper);
	return 0;
}