Problem:
Multi-ending Story

You are a programmer who loves bishojo games (a sub-genre of dating simulation games).
A game, which is titled "I * C * P * C!" and was released yesterday, has arrived to you just now.
This game has multiple endings. When you complete all of those endings, you can get a special figure of the main heroine, Sakuya.
So, you want to hurry and play the game!
But, let's calm down a bit and think how to complete all of the endings in the shortest time first.

In fact, you have a special skill that allows you to know the structure of branching points of games.
By using the skill, you have found out that all of the branching points in this game are to select two choices "Yes" or "No", and once a different choice is taken the branched stories flow to different endings; they won't converge any more, like a binary tree.
You also noticed that it takes exactly one minute to proceed the game from a branching point to another branching point or to an ending.
In addition, you can assume it only takes negligible time to return to the beginning of the game (``reset'') and to play from the beginning to the first branching point.

The game has an additional feature called "Quick Save", which can significantly reduce the playing time for completion.
The feature allows you to record the point where you are currently playing and return there at any time later.
You can record any number of times, but you can hold only the last recorded point.
That is, when you use Quick Save, you overwrite the previous record. If you want to return to the overwritten point, you must play the game from the beginning once again.

Well, let's estimate how long it will take for completing all of the endings in the shortest time.

Input

A data set is given in the following format.

The first line of the data set contains one integer N (2 \leq N \leq 500{,}000), which denotes the number of the endings in this game.
The following N-1 lines describe the branching points.
The i-th line describes the branching point of ID number i and contains two integers Yes_i and No_i (i + 1 \leq Yes_i, No_i \leq N), which denote the ID numbers of the next branching points when you select Yes or No respectively.
Yes_i = N means that you can reach an ending if you select Yes, and so for No_i = N.
The branching point with ID 1 is the first branching point.
The branching points with ID between 2 and N-1 (inclusive) appear exactly once in Yes_i's and No_i's.

Output

Print the shortest time in a line.

Sample Input 1

4
2 3
4 4
4 4

Output for the Sample Input 1

6

Sample Input 2

5
5 2
3 5
5 4
5 5

Output for the Sample Input 2

8

Solution in C++11 (judge verdict: Runtime Error)

#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;

constexpr int MAX_N = 500000;
int n;
int l[MAX_N], r[MAX_N];

int leafs[MAX_N + 1];
int depth[MAX_N + 1];
int memo[MAX_N][2];

int dfs(int v, bool used) {
	if(v == n) return 0;

	int &res = memo[v][used];
	if(res != -1) return res;

	if(used) {
		res = dfs(l[v], true) + dfs(r[v], true) + depth[v] + 2;
	}
	else {
		res = min({dfs(l[v], false) + dfs(r[v], true)  + 2 - (leafs[r[v]] - 1) * depth[v],
				   dfs(l[v], true)  + dfs(r[v], false) + 2 - (leafs[l[v]] - 1) * depth[v],
				   dfs(l[v], false) + dfs(r[v], false) + 2 + depth[v]});
	}

	return res;
}

int init(int v, int d) {
	depth[v] = d;
	return leafs[v] = (v == n ? 1 : init(l[v], d + 1) + init(r[v], d + 1));
}

int main() {
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	cin >> n;

	for(int i = 1; i < n; ++i) {
		cin >> l[i] >> r[i];
	}

	init(1, 0);

	memset(memo, -1, sizeof(memo));
	for(int v = n - 1; v > 1; --v) {
		dfs(v, false);
		dfs(v, true);
	}
	cout << dfs(l[1], false) + dfs(r[1], false) + 2 << endl;

	return EXIT_SUCCESS;
}