Problem p03824 - Generation 3

Orig Description

Score : 1400 points
Problem StatementWe will recursively define uninity of a tree, as follows: (Uni is a Japanese word for sea urchins.)
A tree consisting of one vertex is a tree of uninity 0.
Suppose there are zero or more trees of uninity k, and a vertex v. If a vertex is selected from each tree of uninity k and connected to v with an edge, the resulting tree is a tree of uninity k+1.
It can be shown that a tree of uninity k is also a tree of uninity k+1,k+2,..., and so forth.
You are given a tree consisting of N vertices.
The vertices of the tree are numbered 1 through N, and the i-th of the N-1 edges connects vertices a_i and b_i.
Find the minimum k such that the given tree is a tree of uninity k.
Constraints
2 ≦ N ≦ 10^5
1 ≦ a_i, b_i ≦ N(1 ≦ i ≦ N-1)
The given graph is a tree.
InputThe input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
OutputPrint the minimum k such that the given tree is a tree of uninity k.
Sample Input 17
1 2
2 3
2 4
4 6
6 7
7 5
Sample Output 12
A tree of uninity 1 consisting of vertices 1, 2, 3 and 4 can be constructed from the following: a tree of uninity 0 consisting of vertex 1, a tree of uninity 0 consisting of vertex 3, a tree of uninity 0 consisting of vertex 4, and vertex 2.
A tree of uninity 1 consisting of vertices 5 and 7 can be constructed from the following: a tree of uninity 1 consisting of vertex 5, and vertex 7.
A tree of uninity 2 consisting of vertices 1, 2, 3, 4, 5, 6 and 7 can be constructed from the following: a tree of uninity 1 consisting of vertex 1, 2, 3 and 4, a tree of uninity 1 consisting of vertex 5 and 7, and vertex 6.
Sample Input 212
1 2
2 3
2 4
4 5
5 6
6 7
7 8
5 9
9 10
10 11
11 12
Sample Output 23

Extracted Specification

An integer N (2 ≤ N ≤ 10^5), representing some quantity or size.
A list of N-1 tuples (a_i, b_i), where each tuple contains two integers (1 ≤ a_i, b_i ≤ N).

### Example Input:

```
7
1 2
2 3
2 4
4 6
6 7
7 5
```

### Function Signature:
Write a function f(N, edges) that takes in the input.
```python
def f(N: int, edges: List[Tuple[int, int]]):
    '''
    N: an integer
    edges: a list of tuples containing two integers
    '''
```

Test Case Generator

Certainly! Let's write a test case generator for the given problem statement. The generator will create random trees adhering to the constraints specified.

### Test Case Generator

```python
import random

def generate_tree(N):
    edges = []
    for i in range(2, N + 1):
        edges.append((random.randint(1, i - 1), i))
    random.shuffle(edges)
    return edges

def tcgen():
    N = random.randint(2, 10**5)
    edges = generate_tree(N)
    return N, edges

def format_tc(N, edges):
    result = [str(N)]
    for a, b in edges:
        result.append(f"{a} {b}")
    return "\n".join(result)

# Example usage
if __name__ == "__main__":
    test_cases = [tcgen() for _ in range(5)]  # Generating 5 test cases
    for tc in test_cases:
        N, edges = tc
        print(format_tc(N, edges))
        print("\n---\n")
```

### Explanation

1. **generate_tree(N)**:
    - This function generates a tree with `N` vertices.
    - We start from vertex 2 to N, and for each vertex, we randomly choose a parent vertex from the range `[1, i-1]`. This ensures that the generated structure is a tree.

2. **tcgen()**:
    - Generates a random value for `N` within the given constraints.
    - Calls `generate_tree(N)` to get the edges for the tree.
    - Returns the generated value of `N` and the list of edges.

3. **format_tc(N, edges)**:
    - Formats the test case into the required input format for the problem.
    - Combines the number of vertices and the edges into a single string with appropriate new line separations.

4. **Example usage**:
    - Generates 5 test cases and prints them in the required format.

This code will create valid random test cases for the given problem statement. Each test case represents a tree with a specified number of vertices and corresponding edges, formatted correctly for use in competitive programming.

Extract Arguments

def extract_arguments(fh):
    N = int(fh.readline().strip())
    edges = []
    for _ in range(N-1):
        a, b = map(int, fh.readline().strip().split())
        edges.append((a, b))
    return N, edges