#include <vector>
#include <queue>
#include <utility>
#include <algorithm>
#include <assert.h>
#include <atcoder/segtree>
#include <iostream>
using namespace std;

std::pair<int,int> _max(std::pair<int,int> a,std::pair<int,int> b){
  return a > b ? a : b;
}

std::pair<int,int> _e(){
  return std::make_pair(-1,-1);
}

class ContinuousPriorityQueue{
  private:
    std::vector<std::priority_queue<int>> _vec;
    atcoder::segtree<std::pair<int,int>,_max,_e> _seg;
    // val,index
  public:
    ContinuousPriorityQueue(int maxsize=200000){
      _seg=atcoder::segtree<std::pair<int,int>,_max,_e>(maxsize);
      _vec.reserve(maxsize);
    }
    int top(int l,int r){
      assert(0<=l && l<_vec.size() && 0<=r && r<=_vec.size());
      return _seg.prod(l,r).first;
    }
    int pop(int l,int r){
      assert(0<=l && l<_vec.size() && 0<r && r<=_vec.size());
      std::pair<int,int> max_p=_seg.prod(l,r);
      if(max_p==_e()){
        return -1;
      }
      int res=max_p.first;
      _vec[max_p.second].pop();
      if(_vec[max_p.second].empty()){
        _seg.set(max_p.second,_e());
      }else{
        _seg.set(max_p.second,std::make_pair(_vec[max_p.second].top(),max_p.second));
      }
      return res;
    }
    void add(int index,int val){
      assert(0<=index && index<_vec.size());
      _vec[index].push(val);
      _seg.set(index,std::make_pair(_vec[index].top(),index));
      return;
    }
    void add_back(int val){
      assert(!_vec.empty());
      _vec.back().push(val);
      _seg.set(_vec.size()-1,std::make_pair(_vec.back().top(),_vec.size()-1));
      return;
    }
    void push_back(){
      _vec.push_back(std::priority_queue<int>());
      return;
    }
    int size(){
      return _vec.size();
    }
    bool empty(int index){
      return _vec[index].empty();
    }
    void _print(){
      for(int i=0;i<_vec.size();i++){
        priority_queue<int> pq=_vec[i];
        while(!pq.empty()){
          cout<<pq.top()<<" ";
          pq.pop();
        }cout<<endl;
      }
    }
};

vector<vector<int>> G;

ContinuousPriorityQueue CPQ;
vector<int> depth;
vector<int> parent;
vector<vector<int>> children;

void dfs(int point,int dep){
  depth[point]=dep;
  for(int to:G[point]){
    if(depth[to]==-1){
      dfs(to,dep+1);
      children[point].push_back(to);
    }else{
      parent[point]=to;
    }
  }
  return;
}

int dfs2(int point){
  vector<int> pq;
  int pre=CPQ.size();
  for(int to:children[point]){
    int tmp=dfs2(to);
    pq.push_back(tmp);
  }
  int res=1;
  //cerr<<"point:"<<point+1<<endl;
  if(!pq.empty()){
    CPQ.push_back();
    for(int i:pq){
      CPQ.add_back(i);
    }
    //cerr<<"pre:"<<pre<<endl;
    //cerr<<"size:"<<CPQ.size()<<endl;
    int t1=CPQ.pop(pre,CPQ.size());
    res+=max(0,t1);
    //cerr<<"t1:"<<t1<<endl;

    int t2=CPQ.pop(pre,CPQ.size());
    res+=max(0,t2);
    //cerr<<"t2:"<<t2<<endl;
  }
  //cerr<<"res:"<<res<<endl;
  // CPQ._print();
  return res;
}

int main(){
  int N;
  cin>>N;
  G.resize(N);
  depth.resize(N,-1);
  parent.resize(N,-1);
  children.resize(N);
  for(int i=0;i<N-1;i++){
    int A,B;
    cin>>A>>B;
    G[A-1].push_back(B-1);
    G[B-1].push_back(A-1);
  }
  dfs(0,0);
  int ans=dfs2(0);
  cout<<ans<<endl;
  //CPQ._print();
  return 0;
}