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 Common Lisp (SBCL 1.1.14) (judge verdict: Runtime Error)

(define N (read))
(define alledges (make-vector N '()))
(map (lambda (NO-USE)
       (let [(u (- (read) 1))
	     (v (- (read) 1))]
	 (set! (vector-ref alledges u)
	       (cons v (vector-ref alledges u)))
	 (set! (vector-ref alledges v)
	       (cons u (vector-ref alledges v)))))
     (make-list (- N 1)))
(define (remove* ele lst)
  (cond [(null? lst) lst]
	[(= ele (car lst))
	 (remove* ele (cdr lst))]
	[else
	 (cons (car lst)
	       (remove* ele (cdr lst)))]))
(define (get-fewest-paths-sons sons pa)
  (if (null? sons)
      0
      (+ (get-fewest-paths (car sons) pa)
	 (get-fewest-paths-sons (cdr sons) pa))))
(define (get-fewest-paths u pa)
  (let [(edges (remove* pa (vector-ref alledges u)))
	(deg (length (vector-ref alledges u)))]
    (set! (vector-ref alledges u) edges)
    (+ (if (odd? deg) 1/2 0)
       (get-fewest-paths-sons edges u))))
(define (let-paired lst lim)
  (letrec [(vec
	    (list->vector (sort lst >))
	    ;; (list->vector lst)
	    )
	   (len (vector-length vec))
	   (pairpos
	    (lambda (lp rp stack sp)
	      (cond
	       [(= lp len) -1]
	       [(and (< rp lp)
		     (or (null? stack)
			 (> (car stack) lp)))
		(pairpos (+ lp 1) rp stack sp)]
	       [else
		(while (and (<= lp rp)
			    (<= (+ (vector-ref vec lp)
				   (vector-ref vec rp)
				   2)
				lim))
		       (set! stack (cons rp stack))
		       (set! rp (- rp 1)))
		(cond
		 [(and
		   (not (null? stack))
		   (= lp (car stack))
		   (null? (cdr stack)))
		  (vector-ref vec lp)]
		 [(null? stack)
		  (if (and sp
			   (<= (vector-ref vec lp) lim))
		      (let [(con-ret (pairpos (+ lp 1) rp stack #f))]
			(cond
			 [(not con-ret) #f]
			 [(odd? len) (vector-ref vec lp)]
			 [else con-ret]))
		      #f)]
		 [else
		  (when (= lp (car stack))
			(set! stack (cdr stack)))
		  (pairpos (+ lp 1) rp (cdr stack) sp)])])))
	   (res
	    (pairpos 0 (- len 1) '() #t))]
    res))
(define (find* ele lst)
  (cond
   [(null? lst) #f]
   [(eq? ele (car lst)) #t]
   [else (find* ele (cdr lst))]))
(define (check-OK? u pa lim)
  (let* [(edges (vector-ref alledges u))
	 ;; (son-ret (map (lambda (v) (check-OK? v u lim))
	 ;; 	       edges))
	 (son-ret '())]
    (while (and (not (null? edges))
    		(or (null? son-ret)
    		    (car son-ret)))
    	   (set! son-ret
    		 (cons (check-OK? (car edges) u lim)
    		       son-ret))
    	   (set! edges (cdr edges)))
    (if (find* #f son-ret)
    	#f
    	(let [(pair-ret (let-paired son-ret lim))]
    	  (if pair-ret
    	      (+ pair-ret 1)
    	      #f)))))

(define (check-OK?-lr lv rv)
  (if (= (+ lv 1) rv)
      lv
      (let* [(mid (quotient (+ lv rv) 2))
	     ;; (NO-USE (print "check-OK?-lr " (- mid 1)))
	     (check-res (check-OK? 0 -1 (- mid 1)))]
	(if (and check-res
		 (<= check-res (- mid 1)))
	    (check-OK?-lr lv mid)
	    (check-OK?-lr mid rv)))))
(print (get-fewest-paths 0 -1) " " (check-OK?-lr 0 (+ N 1)))