Question

For the following code :

 s = 0 ;  
 for(i=m ; i<=(2*n-1) ; i+=m)  {  
      if(i<=n+1){ 
        s+=(i-1)/2 ; 
      }  
      else{ 
        s+=(2*n-i+1)/2 ; 
      }    
 }

I want to change the complexity of the code from O(n)
to O(1) . So I wanted to eliminate the for loop . But as
the sum s stores values like (i-1)/2 or (2*n-i+1)/2 so eliminating the loop involves tedious calculation of floor value of each (i-1)/2 or (2*n-i+1)/2 . It became very difficult for me to do so as I might have derived the wrong formula in sums of floors . Can u please help me in Changing complexity from O(n) to O(1). Or please help me with this floor summations . Is there any other way to reduce the complexity ? If yes … then how ?

Answer 1

As Don Roby said, there is a plain old arithmetic solution to your problem. Let me show you how to do it for the first values of i.

* EDIT 2 : CODE FOR THE LOWER PART *

    for(int i=m ; i<= n+1 ; i+=m)//old computation
          s+=(i-1)/2 ;


    int a = (n+1)/m; // maximum value of i
    int b = (a*(a+1))/2; //
    int v = 0;
    int p;
    if(m % 2 == 0){
        p = m/2;
        v = b*p-a; // this term is always here
    }
    else{
        p = (m - 1)/2;
        int sum1 = ((a/2)*(a/2 +1))/2; 
        int sum2 =  (((a-1)/2)*((a-1)/2 +1))/2;  

        v = b*p -a ;// this term is always here
        v+= sum1 + a/2; //sum( 1 <= j <= a )(j-1), j pair
        v+= sum2; //sum( 1 <= j <= a )(j-1), j impair
    }
    System.out.println( " Are both result equals ? "+ (s == v));

How do I come up with it? I take

 for(i=m ; i<= n+1 ; i+=m)
      s+=(i-1)/2 ;

I make a change

 for(j=1 ; j*m <= n-1 ; j++)
     s+=(j*m-1)/2 ;

I pose a=Math.floor(n+1/m). There are 3 cases :

1. m is pair, then interior of the loop is s+= p*j. The result is

    b(a*(a+1))/2 -a
   

2. m is impair and the iterator j is pair

3. m is impair and the iterator j is impair
   When m is impair, you can write m = 2p + 1 and the interior of the loop becomes

    s+= p*j + (j-1)/2
   

p*j is the same as before, now you need to break the division by assuming j is always pair or j always impair and summing both values.

The next loop you need to compute is

 for(int i=a+1 ; i<= (2*n-1) ; i+=m)// a is (n+1)/m
    s+=(2*n-i+1)/2;

which is the same as

 for(int i=1 ; i<= (2*n-1)-a ; i+=m)
    s+= (2n-a)/2 - (i-1)/2;

This loop is similar to the first one, so there is not much work to do…
Indeed this is tedious..