The Airport With The Most Traffic - Leetcode Solution

The Airport With The Most Traffic problem on leetcode is a medium level problem that requires a good understanding of graphs and their properties. The problem is defined as follows:

You are given a list of airline flights with the origin and the destination airports. Your task is to find the airport that has the maximum number of direct flights (both inbound and outbound). If there are multiple airports with the same maximum number of direct flights, return the airport with the smallest index.

The input to the problem is a list of tuples where each tuple represents a flight. The first element of the tuple is the origin airport, and the second element is the destination airport. The output of the problem is the airport with the maximum number of direct flights.

One possible solution to this problem is to build a graph using the input flights. Each airport is represented as a node in the graph, and the flights are represented as edges between the nodes. We can then use a depth-first search or breadth-first search algorithm to traverse the graph and count the number of flights for each airport.

Here is the step-by-step solution to the problem:

Step 1: Build the graph

To build the graph, we can use a dictionary where the keys are the airports and the values are the list of airports reachable from the key. We can iterate through the input flights and add the origin and destination airports as keys to the dictionary. We can then add the destination airport to the list of reachable airports for the origin airport.

Here is the Python code for building the graph:

def build_graph(flights):
    graph = {}
    for flight in flights:
        origin, dest = flight
        if origin not in graph:
            graph[origin] = []
        graph[origin].append(dest)
        if dest not in graph:
            graph[dest] = []
    return graph

Step 2: Traverse the graph

Once we have built the graph, we can use a depth-first search or breadth-first search algorithm to traverse the graph and count the number of flights for each airport. We can keep track of the number of flights for each airport in a dictionary. We can also keep track of the maximum number of flights and the airport with the maximum number of flights.

Here is the Python code for traversing the graph:

def dfs(node, graph, visited, flight_count):
    visited.add(node)
    if node not in graph:
        return
    for neighbor in graph[node]:
        if neighbor not in visited:
            flight_count[node] += 1
            dfs(neighbor, graph, visited, flight_count)

def get_busiest_airport(flights):
    graph = build_graph(flights)
    flight_count = {}
    for airport in graph:
        flight_count[airport] = 0
    max_flights = 0
    busiest_airport = None
    for airport in graph:
        visited = set()
        dfs(airport, graph, visited, flight_count)
        if flight_count[airport] > max_flights:
            max_flights = flight_count[airport]
            busiest_airport = airport
    return busiest_airport

In the above code, we use depth-first search to traverse the graph. We start from each airport and visit all the reachable airports. We keep track of the number of flights for each airport in the flight_count dictionary. We also keep track of the maximum number of flights and the airport with the maximum number of flights.

Step 3: Test the solution

To test the solution, we can create some sample input flights and call the get_busiest_airport function. Here is an example:

flights = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'A'), ('D', 'B'), ('E', 'C'), ('F', 'G')]
print(get_busiest_airport(flights)) #=> 'C'

In the above code, we have created some sample input flights and called the get_busiest_airport function. The output of the function is 'C', which is the airport with the maximum number of direct flights (4).

1