Problem:
Score : 900 points

Problem Statement

We have a tree with N vertices.
The vertices are numbered 0 through N - 1, and the i-th edge (0 ≤ i < N - 1) comnnects Vertex a_i and b_i.
For each pair of vertices u and v (0 ≤ u, v < N), we define the distance d(u, v) as the number of edges in the path u-v.

It is expected that one of the vertices will be invaded by aliens from outer space.
Snuke wants to immediately identify that vertex when the invasion happens.
To do so, he has decided to install an antenna on some vertices.

First, he decides the number of antennas, K (1 ≤ K ≤ N).
Then, he chooses K different vertices, x_0, x_1, ..., x_{K - 1}, on which he installs Antenna 0, 1, ..., K - 1, respectively.
If Vertex v is invaded by aliens, Antenna k (0 ≤ k < K) will output the distance d(x_k, v).
Based on these K outputs, Snuke will identify the vertex that is invaded.
Thus, in order to identify the invaded vertex no matter which one is invaded, the following condition must hold:

For each vertex u (0 ≤ u < N), consider the vector (d(x_0, u), ..., d(x_{K - 1}, u)). These N vectors are distinct.

Find the minumum value of K, the number of antennas, when the condition is satisfied.

Constraints

2 ≤ N ≤ 10^5

0 ≤ a_i, b_i < N

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
a_0 b_0
a_1 b_1
:
a_{N - 2} b_{N - 2}

Output

Print the minumum value of K, the number of antennas, when the condition is satisfied.

Sample Input 1

5
0 1
0 2
0 3
3 4

Sample Output 1

2

For example, install an antenna on Vertex 1 and 3.
Then, the following five vectors are distinct:

(d(1, 0), d(3, 0)) = (1, 1)

(d(1, 1), d(3, 1)) = (0, 2)

(d(1, 2), d(3, 2)) = (2, 2)

(d(1, 3), d(3, 3)) = (2, 0)

(d(1, 4), d(3, 4)) = (3, 1)

Sample Input 2

2
0 1

Sample Output 2

1

For example, install an antenna on Vertex 0.

Sample Input 3

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

Sample Output 3

3

For example, install an antenna on Vertex 0, 4, 9.

Solution in Lua (LuaJIT 2.1.0) (judge verdict: Wrong Answer)

local n = io.read("*n")
local edge = {}
for i = 1, n do
  edge[i] = {}
end
for i = 1, n - 1 do
  local a, b = io.read("*n", "*n")
  a = a + 1
  b = b + 1
  table.insert(edge[a], b)
  table.insert(edge[b], a)
end

local function getend(start)
  local len = {}
  for i = 1, n do
    len[i] = -1
  end
  len[start] = 0
  local mlenidx = 1
  local tasks = {start}
  while 0 < #tasks do
    local src = tasks[#tasks]
    table.remove(tasks)
    for i = 1, #edge[src] do
      local dst = edge[src][i]
      if len[dst] < 0 then
        len[dst] = len[src] + 1
        if len[mlenidx] < len[dst] then
          mlenidx = dst
        end
        table.insert(tasks, dst)
      end
    end
  end
  return mlenidx
end
local root = getend(1)

local parent = {}
local asked = {}
local asked_child_cnt = {}
local tasks = {}
local required = {}
for i = 1, n do
  required[i] = false
  parent[i] = 0
  asked[i] = false
  asked_child_cnt[i] = 0
  if #edge[i] == 1 then
    if i ~= root then
      table.insert(tasks, i)
    end
  end
end
local done = 0
while done < #tasks do
  done = done + 1
  local child = tasks[done]
  asked[child] = true
  if child == root then break end
  if 3 <= #edge[child] then
    required[child] = true
  end
  for i = 1, #edge[child] do
    local pcand = edge[child][i]
    if not asked[pcand] then
      parent[child] = pcand
      asked_child_cnt[pcand] = asked_child_cnt[pcand] + 1
      if asked_child_cnt[pcand] == #edge[pcand] - 1 then
        table.insert(tasks, pcand)
      end
    end
  end
end
-- for i = 1, n do
--   asked[i] = false
-- end
-- asked[root] = true
tasks[1] = edge[root][1]
tasknum = 1
done = 0
local ret = 1
while done < tasknum do
  done = done + 1
  local p = tasks[done]
  local required_cnt = #edge[p] - 2
  for i = 1, #edge[p] do
    local c = edge[p][i]
    if c ~= parent[p] then
      if required[c] then
        required_cnt = required_cnt - 1
      end
      tasknum = tasknum + 1
      tasks[tasknum] = c
    end
  end
  if 0 < required_cnt then
    ret = ret + required_cnt
  end
end
print(ret)