## Root the Tree codechef lunchtime solution| codechef lunchtime problem editorial-

## Problem Statement->

A *directed tree* is a directed graph such that if all edges were undirected, this graph would be a tree. A *rooted directed tree* is a directed tree in which there is one vertex (the *root*, let's denote it by ) such that it is possible to reach all vertices of the graph from by moving along the directed edges.

You are given a directed tree with vertices (numbered through ). You may perform the following operation on it any number of times (including zero):

- Choose some edge which currently exists in the graph.
- Remove this edge.
- Add a new edge in such a way that the graph becomes a directed tree again.

What is the smallest number of operations which need to be performed in order to make the directed tree rooted?

### Input

- The first line of the input contains a single integer denoting the number of test cases. The description of test cases follows.
- The first line of each test case contains a single integer .
- Each of the next lines contains two space-separated integers and denoting that there is a directed edge from to in the tree.

### Output

For each test case, print a single line containing one integer ― the smallest number of operations we need to perform to create a rooted directed tree.

### Constraints

- the graph described on the input is a directed tree
- the sum of over all test cases does not exceed

### Subtasks

Subtask #1 (20 points): for each edge, or (the graph is a directed star)

Subtask #2 (80 points): original constraints

### Example Input

```
2
3
1 2
3 2
3
1 2
2 3
```

### Example Output

```
1
0
```

### Explanation

Example case 1: We can delete the edge from vertex to vertex and insert an edge from to . Then, the graph becomes a rooted directed tree with vertex as the root. However, there are many other possible solutions.

Example case 2: The graph is already a rooted directed tree; the root is vertex .

Problem link-https://www.codechef.com/LTIME88B/problems/ROOTTREE

solution->

According to this problem we have given a graph and we have to convert this graph to a rooted directed tree means every node should have only one incoming edge and 1 outgoing edge.

So my solution approach says that we will store the frequency of incoming edge of each vertex and

if I found incoming edge frequency greater then 1 so will delete this edge and add to the new node so my final answer will increase by ans+=freq[i]-1;

after doing the same for all vertex I will get my final answer.

my code is mentioned below. Please check it .

wait there is no need of creating any 2D boolean array sorry for that so delete that part of code.