Indian National Olympiad in Informatics

Online Programming Contest, 1-2 January 2005

IARCS home > OLYMPIAD

Advanced Division

Solution to Problem 2: What is the Rank?

You are given a list of integers a_1, ... a_N, and your aim is
to determine the rank of a_i among a_1,...,a_i.

Let us dispose off the direct algorithm. For each i, simply scan
from a_i down to a_1 and determine the rank of a_i by counting
the number of elements below (or above) a_i.  This takes time
proportional to i. Thus, summing up over all i, this algorithm
takes roughly N*N steps.  This will get you 30% of the marks.

On the face of it, this problems seems similar to the "End of
Corruption" problem, where we had a stream of numbers coming in
and we had to insert the numbers into a list. We were also
required to find the current maximum element in the list and
delete it.

Recall, from the discussion in that problem, that we could
maintain the list either in sorted order or in the order in which
the numbers arrive.  Maintaining the list in sorted order would
require us to spend time proportional to the length of the list
in order to insert an element into it. On the other hand, if we
choose to maintain the numbers in the order in which they arrive,
then, each insertion cost us only one instruction.

If the list is maintained in arbitrary order, then finding the
rank of an element will take take proportional to the length of
the list. The naive algorthim described above uses this idea and
cannot be improved.

On the other hand if the list is maintained in sorted order, then
we can find the rank of an element in time proportional to log(n)
where n is the number of elements in the list. Here is how:

Suppose a_1 > a_2 > a_3 > ... a_n and the next element is x.
(Recall from the statment of the problem the x is different from
a_1 ... a_n.)

If x > a_1 (or x < a_n) then its rank is 1 (is n+1).  Otherwise,
compare x with the "middle element" of the list.  The middle
element is a_m where m = n/2 (/ denotes integer division).

   1) If x > a_m then it suffices to find the rank of x in the
      list a_1 ... a_{m-1}.

   2) If x < a_m and x > a_{m+1} then rank of x is m+1.

   3) If x < a_{m+1} then it suffices to find the rank of x in
      the list a_{m+1} ... a_n and add m to it.

Notice that after making the necessary comparisons required by 1,
2 and 3, we are left with a list whose length is < n/2.  In
finding the rank of x in this smaller list we will apply the same
ideas above, i.e. compare it with the middle element and then
restrict the search to a list whose length < (n/2)/2 = n/4 and so
on.  This repeated halving can go on for at most log(n)
steps. The details are as follows:

We now formulate a recursive algorithm motivated by the above
idea.

----------------------------------------------------------------

/*
   The numbers are available in the array A.
   The number of elements in the array is n.
   The array A is in descending order
*/

    /* 
       findrank takes 3 arguments, x,l and r
       where 1 ≤ l ≤ r ≤ n and returns the rank
       of x in the list A[l], A[l+1], ... A[r] 
    */

    findrank(x,l,r) {

        if (x > A[l]) return(1)
        if (x < A[r]) return(r-l+2)

        mid = (l + r)/2

        if (x > A[mid]) return(findrank(x,l,mid-1))  /* 1 above
        else if (x > A[mid+1]) return(mid-l+1)       /* 2 above
             else return(mid+findrank(x,mid+1,r))    /* 3 above

    }

    print(findrank(x,1,n))

-----------------------------------------------------------

As mentioned earlier if there are n elements in the list
(i.e. between l and r) when findrank is called, in any recursive
call there are at most n/2 elements. Thus, there are at most
log(n) (i.e. the smallest k such that 2^k is more than n)
recursive calls before the list is empty. Each call, carries out
a fixed number, say k instructions and thus the total number of
instructions executed is log(n)*k which is roughly log(n).

Exercises:

1) Write down a non-recursive version of this algorithm.

2) If we are only interested in the rank of x in the entire array
   (and do not require that findrank(x,l,r) return the rank of x
    among the elements A[l],..., A[r], then, we can simply the
   above function considerably. How?


So what do we have so far:

1) Maintain the list in the order in which the numbers arrive.
   Each insert takes only a contant number of steps but finding
   the rank takes time proportional to the length of the
   list. Thus, if there are N elements in all we would time
   proportional to N*1 + N*N (the first term is contributed by
   the inserts and the second one is the time taken in finding
   the ranks). Thus the time taken is roughly N*N.

2) Maintain the array in sorted order. Each insert takes time
   proportional to the length of the list.  Thus inserting N
   element takes time proportional to N*N. Finding the rank of an
   element takes time proportional to log(n) where n is the
   current length of the list. So the overall time time taken to
   find the rank of the N elements (as they are inserted) is not
   more than N*log(N). N*log(N) + N*N is roughly N*N (since
   log(N) is much smaller than N).

So, there is no real difference between the two. But, if we
learnt our lessons (from the "End of Corruption" problem) right,
we would like to balance the efficiency of the inserts in the
first algorithm with the efficiency of the rank finding in the
second algorithm. And this is how you do it:

We use Sqrt(N) lists, each containing at most Sqrt(N) numbers,
and each of these lists is maintained in sorted order.

To insert an element, we look for the first list with space (that
will take time proportional to Sqrt(N)) and then insert it into
the list at the appropriate place (to maintain the sorted order)
and this take time proportional to Sqrt(N). Thus each insert
takes time proportional to Sqrt(N).

To find the rank of an element, we find its rank in each of the
Sqrt(N) lists.  That takes time proportional to Sqrt(N) *
log(Sqrt(N)).  Suppose, the rank in the Sqrt(N) lists are
r_1,r_2,...,r_Sqrt(N). Then, the overall rank is (r_1 - 1) + (r_2
- 1) + ... + (r_Sqrt(N) - 1) + 1. (Since there are (r_i - 1)
elements in list i bigger than the given number.)  Thus the rank
can be found in time proportional to Sqrt(N)*log(Sqrt(N)).

So the overall time of inserting and finding the current rank of
N elements is proportional to N*(Sqrt(N) + log(Sqrt(N))). Note
that log(N) = 2 * log(Sqrt(N)). Thus, this is roughly
N*Sqrt(N)*log(N). Since log(N) is much smaller than Sqrt(N) (for
example if N is 40000, Sqrt(N) is 200 and log(N) is 16) this
algorithm performs significantly better than one that takes time
proportional to N*N. This algorithm would get you 100% marks.

Here is the full algorithm. We use a 2-dimensional array of size
Sqrt(N) X Sqrt(N). Each row stores a list. We also keep an array
Next[] of size Sqrt(N) to keep track of the first vacant position
in each of the Sqrt(N) lists.

---------------------------------------------------------------------

integer array  A[Sqrt(N)][Sqrt(N)]
integer array  Next[Sqrt(N)]

for i=1 to Sqrt(N) {
   Next[i] = 1
}

for i=1 to N  {
   x =  read next input
   y =  Rank(x)
   Insert(x)
   print(y)
}


Insert(x) {
       
   Find the first i such that Next[i] ≤ Sqrt(N). /* Find a list with 
                                                     space */
   
   Find the first j such that A[i][j] ≤ x.  /* Have to insert x at
   (If no such j is found return Next[i])              position j */

   for (k=Next[i] down to j+1)           /* create space to insert x */
         A[i][k]=A[i][k-1]
        
   A[i][j] = x                        /* insert x */
   Next[i] = Next[i] + 1

}

/* 
   A function that finds the rank of the element x among the 
   elements between positions l and r in row i of the Array A 
   (The same as the findrank above except that instead of working
   over a one dimensional array A it works over the row i of
   a two dimensional array A) 
*/


findrowrank(i,x,l,r) {

   if (x > A[i][l]) return(1)
   if (x < A[i][r]) return(r-l+2)

   mid = (l + r)/2

   if (x > A[i][mid]) return(findrowrank(i,x,l,mid-1))  
   else if (x > A[i][mid+1]) return(mid-l+1)      
        else return(mid+findrowrank(i,x,mid+1,r))    
}

 

Rank(x) {
   rank = 0

   for (i=1 to Sqrt(N))    { /* add up the number of elements below
                                x in all the rows */
               rank = rank + findrowrank(i,x,1,Next[i]-1) - 1 

   }
   /* rank has the number of elements below x in the entire
      two dimensional array now. So the Rank of x is rank+1 */

   return(rank+1)

}         
       
--------------------------------------------------------------------
                    
It turns out that one do a lot better than what is described here
using a very specialised data structure. One can do the N inserts
and find the ranks in overall time proportional to
N*log(N). Thus, for N = 40000, that algorithm would be about 200
(Sqrt(40000)) times faster!! We postpone a discussion on this
data structure for the moment.

We would like to add now that the algorithm for finding the rank
described above can be modified to find out whether x is a
already present in sorted array of size N in time proportional to
log(N).  This technique is called "binary search" and we describe
that algorithm below for the sake of completeness (you are
encouraged to work it out for yourselves and not read on!).

Binary Search:
--------------

Let A be a array with N elements sorted in ASCENDING order. 
Given x, we would like to know if x appears in A.   (The array 
could contain duplicates and of course x could appear in A.)

The naive algorithm would scan the array  and would take time
proportional to the length of the array.

The binary search algorithm works very much like the "findrank" 
described above. 

-----------------------------------------------------------------

/* 
   The algorithm bsearch takes 3 inputs, x, l and r.
   It returns 0 if x does not appear among A[l] ... A[r].
   Otherwise, it returns an index j, l ≤ j ≤ r such that
   A[j] = x                                     
*/


int bsearch(int x, int l, int r) {

   int mid;
   mid = (l+r)/2;

   /* x is smaller than the smallest element in A */
   if (x < A[l]) return(0);

   /* x is bigger than the largest element in A */
   if (x > A[r]) return(0);

   /* x is smaller than A[mid]. So it cannot appear among 
      A[mid],A[mid+1],...A[r] */
   if (x < A[mid]) return(bsearch(x,l,mid-1));

   /* x is bigger than A[mid] so it cannot appear among 
      A[1],A[2],... A[mid] */
   if (x > A[mid]) {
           /* if x is also less than A[mid+1] then x does not appear 
              in A */
           if (x < A[mid+1]) return(0);
           
            /* Otherwise, search among A[m+1], ... A[r] */
           return(bsearch(x,mid+1,r));
   }

   /* x equals A[mid] */

   return(mid);

}

-----------------------------------------------------------------------

As in the case of findrank, noting that each recursive call
reduces the distance between l and r by half, guarantees that
there are at most Log(N) recursive calls to bsearch and since
each call takes only a constant number of operations the overall
algorithm takes roughly Log(n) steps.


Exercise: Can we use the binary search algorithm to solve the
Average problem (the other problem in the January problem set) in
N*N*log(N) steps (needless to add, without using the ideas
leading to the N*N solution).





Copyright (c) IARCS 2003-2018;   Last Updated: 29 Mar 2005