#include<iostream>

#include<cstdio>

#include<cmath>

#include<cstring>

#include<sstream>

#include<algorithm>

#include<queue>

#include<deque>

#include<iomanip>

#include<vector>

#include<cmath>

#include<map>

#include<stack>

#include<set>

#include<functional>

#include<fstream>

#include<memory>

#include<list>

#include<string>

using namespace std;

typedef long long LL;

typedef unsigned long long ULL;

#define N 31

#define MAXN 20000 + 9

#define INF 1000000009

#define eps 0.00000001

#define sf(a) scanf("%d",&a)

/*

N台电脑构成树！

选点做服务器，最小支配集！

注意这里每个电脑只能从一台服务器上获得信息，说明不能有一个点和两个支配集的点相连！

所以dp[u][1]的状态就是不可行的！

*/

struct edge

{

    int to, next;

}E[MAXN*];

int head[MAXN];

int cnt, n, dp[MAXN][];

void init()

{

    cnt = ;

    memset(dp, , sizeof(dp));

    memset(head, -, sizeof(head));

}

void addedge(int u, int v)

{

    E[cnt].to = v;

    E[cnt].next = head[u];

    head[u] = cnt++;

}

void Dp(int u, int p)

{

    dp[u][] = ;

    dp[u][] = ;

    bool f = false;

    int sum = , inc = INF;

    for (int i = head[u]; i != -; i = E[i].next)

    {

        int v = E[i].to;

        if (v == p)

            continue;

        Dp(v, u);

        dp[u][] += min(dp[v][], dp[v][]);

        if (dp[v][] < dp[v][])

        {

            f = true;

            sum += dp[v][];

        }

        else

        {

            inc = min(inc, dp[v][] - dp[v][]);

            sum += dp[v][];

        }

        if (dp[v][] != INF&&dp[u][] != INF)

            dp[u][] += dp[v][];

        else

            dp[u][] = INF;

    }

    if (inc == INF && !f)

        dp[u][] = INF;

    else

    {

        dp[u][] = sum;

        if (!f) dp[u][] += inc;

    }

}

int main()

{

    while (scanf("%d", &n) != EOF)

    {

        int f, t;

        init();

        for (int i = ; i < n - ; i++)

        {

            scanf("%d%d", &f, &t);

            addedge(f, t);

            addedge(t, f);

        }

        Dp(, -);

        printf("%d\n", min(dp[][], dp[][]));

        int flag;

        scanf("%d", &flag);

        if (flag == -)

            break;

    }

}