// Arup Guha
// 2/8/2018
// Solution to the 2018 January USACO Gold Problem: At Large

import java.util.*;
import java.io.*;

public class atlarge {

	public static int n;
	public static node[] tree;

	public static void main(String[] args) throws Exception {

		// Store tree.
		BufferedReader stdin = new BufferedReader(new FileReader("atlarge.in"));
		StringTokenizer tok = new StringTokenizer(stdin.readLine());
		n = Integer.parseInt(tok.nextToken());
		int root = Integer.parseInt(tok.nextToken()) - 1;
		tree = new node[n];
		for (int i=0; i<n; i++) tree[i] = new node();

		// Add each edge to the tree.
		for (int i=0; i<n-1; i++) {
			tok = new StringTokenizer(stdin.readLine());
			int v1 = Integer.parseInt(tok.nextToken()) - 1;
			int v2 = Integer.parseInt(tok.nextToken()) - 1;
			tree[v1].next.add(v2);
			tree[v2].next.add(v1);
		}

		// Fill in parents, depths.
		bfs(root);

		// Output to file.
		PrintWriter out = new PrintWriter(new FileWriter("atlarge.out"));
		out.println(solve(root));
		out.close();
		stdin.close();
	}

	public static void bfs(int root) {

		// Set up BFS.
		tree[root].parent = -1;
		tree[root].depth = 0;
		LinkedList<Integer> q = new LinkedList<Integer>();
		boolean[] used = new boolean[n];
		used[root] = true;
		q.offer(root);

		// Stores the order in which nodes were visited.
		ArrayList<Integer> bfsorder = new ArrayList<Integer>();

		// Go through queue.
		while (q.size() > 0) {

			// Get the next item.
			int cur = q.poll();
			bfsorder.add(cur);

			// Enqueue all kids (skip cur's parent).
			for (int i=0; i<tree[cur].next.size(); i++) {
				int next = tree[cur].next.get(i);
				if (used[next]) continue;

				// Here is oru bookkeeping.
				q.offer(next);
				used[next] = true;
				tree[next].parent = cur;
				tree[next].depth = tree[cur].depth + 1;
			}
		}

		// Loop backwards to fill in min depth.
		for (int i=n-1; i>=0; i--) {

			int item = bfsorder.get(i);

			// A base case.
			if (tree[item].next.size() == 1 && tree[item].parent != -1) {
				tree[item].minLeafDepth = 0;
			}

			// We have children - go through each.
			else {

				tree[item].minLeafDepth = n;
				for (int j=0; j<tree[item].next.size(); j++) {
					int kid = tree[item].next.get(j);
					if (kid == tree[item].parent) continue;
					tree[item].minLeafDepth = Math.min(tree[item].minLeafDepth, tree[kid].minLeafDepth+1);
				}
			}
		}
	}

	public static int solve(int root) {

		// Set up BFS.
		int res = 0;
		LinkedList<Integer> q = new LinkedList<Integer>();
		boolean[] used = new boolean[n];
		used[root] = true;
		q.offer(root);

		// Go through queue.
		while (q.size() > 0) {

			// Get the next item.
			int cur = q.poll();

			// This node can't be covered by one cop add kids to queue.
			if (tree[cur].minLeafDepth > tree[cur].depth) {

				// Enqueue all kids (skip cur's parent).
				for (int i=0; i<tree[cur].next.size(); i++) {
					int next = tree[cur].next.get(i);
					if (used[next]) continue;
					q.offer(next);
					used[next] = true;
				}
			}

			// Add to our result and DON'T enqueue, we don't need its kids!!!
			else res++;
		}

		// Ta da!
		return res;
	}
}

class node {

	public ArrayList<Integer> next;
	public int parent;
	public int depth;
	public int minLeafDepth;

	public node() {
		next = new ArrayList<Integer>();
	}
}