2.2.2. Dependency on N and F

In this case, it is fairly obvious that if we have more cities, the problem is more complicated. So the number of cities, which we can call N, is certainly one parameter which determines how complicated the algorithm is going to be or how long it is going to take to run. The other question which determines how complex the network is, is how many direct flights there are. Obviously, if there are fewer flights, there are fewer places which can be connected and we have to explore fewer possibilities.

This chunk introduces the concept of problem complexity in terms of two key variables: N (number of cities) and F (number of direct flights). As the number of cities (N) increases, the potential connections and pathways increase, thus creating a more complex problem. Similarly, the number of direct flights (F) impacts complexity because fewer flights mean fewer possible connections to consider. In essence, both N and F directly affect how complicated the problem is and how long an algorithm may need to execute to find a solution.

Imagine planning a road trip. If you're only considering two towns, the route options are limited, making your planning straightforward. However, if you expand the trip to ten towns, the number of possible routes grows exponentially. Similarly, if some towns are connected by direct highways (direct flights), planning becomes simpler compared to needing to find connections between towns with fewer direct routes.

From this, it follows that computing the paths depends on both N and F. We will not have an algorithm which will always take a twenty steps. It will have to depend on some number of steps depending on N and F. Now what is this dependency, how does it grow? If N doubles, does our algorithm take two times more time? Does it take four times more time? If N grows to a factor of ten, does it take ten times more or a hundred times more time?

This chunk emphasizes the relationship between the problem size (N and F) and algorithm efficiency. Instead of having a fixed execution time, the time taken by the algorithm to compute paths varies depending on how many cities (N) and flights (F) are involved. It introduces important considerations about scalability and performance, asking critical questions about how changes in N affect the algorithm's running time. This leads to questioning whether the time complexity is linear, quadratic, or some other form as N increases.

Consider a chef who has to prepare meals for a dinner party. If there are just five guests, it’s manageable; however, if the guest list doubles to ten, the chef will require more time. If it grows to fifty, the time required could increase significantly depending on the chef's cooking methods. Similarly, in computing flight paths, if more cities are added, the time taken to find the paths can dramatically increase.

Given this dependency on N and F, what realistic size of networks can we handle? If the airline grows to twenty flights, we will still have to be able to give our answer in a reasonable time. Remember that this kind of an answer is typically required when somebody is making an online booking or something. You would not be allowed to reply in a few seconds; it is not enough to come back after an hour and say “yes, there is a flight from Trivandrum to Calcutta”. So, what is the limit of our efficiency? Can we scale this algorithm to cover airlines, multiple airlines?

This chunk discusses the practical limitations of algorithms as they pertain to real-world applications. It highlights that as airlines and flight networks grow in size and complexity, the computational resources and time required to provide answers to users must remain within acceptable limits. The focus here is on understanding the maximum size of networks that an algorithm can effectively handle without violating the requirement for timely responses, particularly in scenarios like online bookings.

When ordering food from an app, if the restaurant selection expands to hundreds of options, the app should still quickly find what you want without lag. If it takes too long to display results because its algorithms can’t handle the data efficiently, users may get frustrated and stop using the app. Similarly, flight booking systems need to function rapidly, even as more airlines and routes are integrated.

The problem we have looked at is a very simple problem; can I get from A to B. But very often it is not good enough to get from A to B. You want to get from A to B within some reasonable time frame. For instance, it is not usually acceptable to break the journey overnight on aircraft. At the same time, you also do not want to spend more than a certain amount of time meeting in between flights.

This chunk introduces the need for additional constraints when finding paths in the flight network. Simply connecting two destination points (from A to B) is too simplistic; often, travelers require specific restrictions like minimum layover times or maximum travel durations. Thus, the challenge becomes even more complex as algorithms need to consider not just connectivity but practical travel concerns and personal preferences.

Think about planning a multi-stop vacation. Not only do you want to travel from one city to another, but you also want to limit your layover to just a couple of hours. If your next flight is the next day, you may need to book a hotel for an overnight stay. A travel-planning tool needs to factor these preferences into its suggestions so that travelers can make choices that suit them best.

--