12.10. Analysis of Time Complexity

So, there is a very simple brute force way to check, because we know that every inversion is a pair i j, such that j appears before i in my friends list. So, we can just check that, we can just check for every i and every j which is different from i, whether i and j is an inversion and this will give us a Brute force order n squared algorithm.

This chunk discusses a straightforward method for counting inversions using brute force. You analyze every possible pair of rankings by comparing how one person ranks items against how another person does. The pairs are evaluated to see if they are inversions, which occurs if one ranking places an item higher than the other. Given that we examine each pair (i, j), the total amount of checks is 0n choose 2, leading to a time complexity of O(n^2).

Imagine two people rating movies based on their preferences. Each person has to look at all the movies and compare rankings. If one person says Movie A is better than Movie B, but the other person says Movie B is better than Movie A, that’s an inversion. If they have to check every possible comparison for a large list of movies, the task becomes cumbersome very quickly, showing the consequence of the O(n^2) complexity.

So, our whole is to give a more efficient algorithm, so we will move to this divide and conquer paradigm. So, suppose your friend’s permutation, our permutation always 1 to n, so we can just assume it is given.

Here, the text introduces the divide and conquer method as an efficient alternative to brute force for counting inversions. Instead of checking all pairs, it suggests breaking the problem down into smaller sub-problems. By splitting the list into halves, counting inversions can be done recursively, and finally merging the results allows for an efficient count of inversions that occur across both halves.

Consider an assembly line processing products in a factory. If you try to assess every single step (like brute force), it’s time-consuming. Instead, if you divide the line into smaller sections, analyze each section’s efficiency, then combine the assessment, you gain insights faster. This is analogous to how divide and conquer works by managing smaller problems.

So, what happens is now we have divide our problem into two parts and then, we come back, so this is my L and this is my R, I have now sorted L sorted R and I have a counters, so I have a count L and a count R.

In this portion, the approach to counting inversions during the merge phase is described. After sorting the two divided lists (L and R), the algorithm can count how many items in R are inversions with respect to items in L while merging them back into one sorted list. Each time an item from R is taken that is less than an item from L, it indicates that all remaining items in L are inversions with the current item from R.

Imagine a situation where you're sorting books on a shelf that has two compartments. While rearranging books from both compartments into a single neat row, every time you pick a book from the second compartment that should come before a book from the first compartment, it’s like uncovering a mismatch. The number of books left in the first compartment (that are to the right of this book from the second compartment) tells you how many inversions there are.

Now, an important think to note is when we did are Brute force calculation, we looked at every possible pair and decided whether or not to is an inversion, so they actually explicitly counted the inversions to get the answer.

This chunk emphasizes the efficiency of the divide and conquer method over brute force. The previous brute force approach may require checking potentially O(n^2) pairs, whereas the divide and conquer method manages to compute inversions in O(n log n) time via recursive counting and merging. This significantly reduces the time required, especially for larger datasets, making it a much more scalable solution.

Think about navigating a busy city. Using brute force, you might check every street (every pair of movements) to find the fastest route, taking a long time. Now, if you divide the city into sectors and find the shortest path within those segments then combine the sectors, you can navigate efficiently and reach your destination faster. This illustrates the efficiency of the divide and conquer method.

--