最坏情况下该算法的下限运行时间

Question

I have an algorithm as follow:

and even I have the anwser for finding lower bound of this algorithm:

But the problem is that I can not understand this: when we set i >= n/2 but n/4<=j<=n/2 then in this algorithm j can not get any value which is but as you see in the answer it says the middle loop iterates n/4?

I am really confused why.

Answer 1

OK, I am not sure which part you are confused about, but let me rephrase lower bound explanation from your abstract, and, perhaps, the confusion part will clear up.

First of all, the lower bound approach (kinda obvious stuff but omitted in your abstract and can be unobvious to beginner students). If you imagine set of all possible values of (i, j, k), we don't want to count them all, but we'll only count a smaller subset of them, defined by certain arbitrary restrictions. It turns out it's easier to compute lower bound on a subset than on the entire set (because you can do simple math like multiplying lower bounds of ranges due to these restrictions), and transitively, this will also be a lower bound for the entire set.

Now, these arbitrary restrictions are choosen the following: 1) Look at only i values >= n/2. That means, instead of looking at [1..n], we look at [n/2..n]. 2) Taking into account the previous restriction, also restrict j: look at j values in range [n/4..n/2]. The word "Consider" in your text applies to both (1) and (2)). Note that the reason we can do that is that [n/4..n/2] is always a subset of the [1..i] range since we already decided that we only look at cases when i >= n/2. Therefore limiting [1..i] to [n/4..n/2] is correct thing to do to get some lower bound.

Now that we know i is [n/2..n] (at least n/2), and j is [n/4..n/2] (at least n/4), there are n/2*n/4 combinations of possible (i, j) pairs. For each of these pairs, the inner loop will do at least n/4-1 iterations (I am not sure why -1, perhaps to signify rounding down?), therefore we get n/2*n/4*(n/4-1) tuples of (i, j, k) is omega(n^3).

If a small subset of variants is omega(n^3), than the original set is omega(n^3) too.

PS I didn't understand why you said "n/4<=j<=n/2 then in this algorithm j can not get any value". n/4 is smaller than n/2, so for big enough n values, j range will have some numbers.

Answer 2

It looks to me like the number of iterations in the middle loop should always be less than or equal to number of iterations in inner loop because k would always go from 1 to j.

Below is an example of where I walked through the loop .

array[1,2,3,4,5]

will produce the following iterations with the restrictions on the loops:

i=3,j=2,k=1 //i starts at 3 because of n/2 minimum
            //j can't go below or above 2 because of condition on middle loop
i=3,j=2,k=2
i=4,j=2,k=1
i=4,j=2,k=2
i=5,j=2,k=1
i=5,j=2,k=2

3 iterations of outer loop (at least n/2)
1 iteration of middle loop for each outer loop iteration (NOT at least n/4)
2 iterations of inner loop for each iteration of middle loop (at least n/4 - 1)

The text may have just swapped the descriptions for the bottom two loops. If this is the case, the answer given would still be correct.

Regardless, the important thing to note is that it runs in O(n^3) time.

Answer 3

You can visualize number of iterations in the loop as

for( i in [1..n] )
  for( j in [1..i] )
     statement;

as (for n = 6):

x 
x x 
x x x
x x x x
x x x x x
x x x x x x

this will give you complexity O(N*N) . Number of iterations in innermost loop (in your sample) is also N dependent so it will give you one more N multiplier (third dimension). So x es will fill 1/32 (?) of cube volume. But as it is a cube formation then complexity will be O(N³)