Counting according to query

Question

Given an array of N positive elements. Lets suppose we list all N × (N+1) / 2 non-empty continuous subarrays of the array A and then replaced all the subarrays with the maxi

Answer 1

Create a sorted value-to-index map. For example,

[34,5,67,10,100] => {5:1, 10:3, 34:0, 67:2, 100:4}

Precalculate the queries in two passes over the value-to-index map:

1. Top to bottom - maintain an augmented tree of intervals. Each time an index is added, split the appropriate interval and subtract the relevant segments from the total:

   indexes    intervals    total sub-arrays with maximum greater than
   4          (0,3)        67 => 15 - (4*5/2)            = 5
   2,4        (0,1)(3,3)   34 => 5 + (4*5/2) - 2*3/2 - 1 = 11 
   0,2,4      (1,1)(3,3)   10 => 11 + 2*3/2 - 1          = 13
   3,0,2,4    (1,1)         5 => 13 + 1                  = 14
   

2. Bottom to top - maintain an augmented tree of intervals. Each time an index is added, adjust the appropriate interval and add the relevant segments to the total:

   indexes    intervals    total sub-arrays with maximum less than
   1          (1,1)         10 => 1*2/2         = 1
   1,3        (1,1)(3,3)    34 => 1 + 1*2/2     = 2 
   0,1,3      (0,1)(3,3)    67 => 2 - 1 + 2*3/2 = 4
   0,1,3,2    (0,3)        100 => 4 - 4 + 4*5/2 = 10
   

3. The third query can be pre-calculated along with the second:

   indexes    intervals    total sub-arrays with maximum exactly
   1          (1,1)         5 =>         1
   1,3        (3,3)        10 =>         1 
   0,1,3      (0,1)        34 =>         2
   0,1,3,2    (0,3)        67 => 3 + 3 = 6
   

Insertion and deletion in augmented trees are of O(log n) time-complexity. Total precalculation time-complexity is O(n log n). Each query after that ought to be O(log n) time-complexity.