Algorithms Q&A - Recent questions in Asymptotic Analysis

Analyze Double Loop - j starts from i*i

Fri, 22 Nov 2024 15:11:57 +0000

for (int i = 1 to n) {
  for (int j = i*i to n) {
   sum += a[i]*b[j]
  }
}

Analyze Triple Loop - j and k start with i^2 and j^2 respectively

Mon, 04 Nov 2024 16:01:18 +0000

for (int i = 1 to n) {

  for (int j = i*i to n) {

    for (int k = j*j to n) {

      sum += a[i]*b[j]*c[k]

    }

  }

}

Nested loop analysis, outer loop grows by sqrt n, inner randomly

Fri, 10 Nov 2023 17:03:51 +0000

j = 1

while (j < n) {

k = j

while (k < log n) {

if (random() < 0.5) {

k += k

} else {

k += 1

}

j += 0.1 * sqrt(n)

}

Solve this recurrence using master theorem: T(n) = 2 T(n/2) + n^0.75

Sun, 10 Sep 2023 19:08:00 +0000

Asymptotically compare 14 T(n/4) + O(n) and 7 R(n/2) + O(n).

Sat, 10 Dec 2022 20:38:22 +0000

Asymptotically compare recurrence relations T and R. Express your answer by writing asymptotic relation between T and R.

T(n) = 14 T(n/4) + O(n). R(n) = 7 R(n/2) + O(n).

Use the limit method to prove the asymptotic relation between these 3 functions

Tue, 25 May 2021 02:10:27 +0000

Use the limit method to prove the asymptotic relation between these 3 functions:

n^2

The limit method says that: lim (n --> infinity) f(n) / g(n) tends to 0, then f(n) = o(g(n)). Similarly, if the limit tends to infinity, then f(n) = small omega (g(n)), and if the limit tends to a constant, then f(n) = theta (g(n)).

Highest sum of tree heights when one recoloring is allowed

Tue, 05 May 2020 22:54:14 +0000

You are given a sequence of n trees. The height of the i-th tree is h[i]. Each tree could be of one of k different colors. You are allowed to do ONE recoloring operation, in which you can recolor ALL trees with color C1, to color C2. Your objective is to MAXIMIZE the total height of contiguous block of trees of one color. Present an algorithm for this problem, and present its time complexity.

For example, suppose your trees are:

Tree T1, Height 17, Color: R (Red)

Tree T2, Height 20, Color: Y (Yellow)

Tree T3, Height 1, Color: G (Green)

Tree T4, Height 5, Color: G (Green)

Tree T5, Height 6, Color: Y (Yellow)

In this case, if you color YàG (or GàY), then the maximum height of G trees is 32. However, if you recolor YàR (or RàY), then the maximum contiguous height becomes 37, and is therefore the correct answer.

outer loop until log n, inner loop exponential increase

Mon, 09 Jul 2018 01:18:16 +0000

Given:

int j = 5
while (j < log n) {
      int k = 5
      while (k < n) {
            Sum += a[j]*b[k]
            k = k^1.3
      }
      j = 1.3 * j
}

Solve the Recurrence Relation: T(n) = T(n/4) + T(3n/4) + n^2

Tue, 08 May 2018 02:40:02 +0000

Time Complexity 0.25 * n and k +=k

Sun, 04 Mar 2018 19:27:16 +0000

j = 1
while (j < n) {
    k = j
    while (k < n) {
        Sum += a[k] * b[k]
        k += k
    }
     j += 0.25 * n
}

From midterm practice

Time Complexity (3 loops with gcd)

Sun, 04 Mar 2018 19:21:54 +0000

for (int i = 1 to n) {
    for(int j = i to n) {
        for(int k = j to n) {
            Sum += a[i] * b[j] * c[k]
        }
        if (gcd(i, j) == 1) {
            j = n
        }
    }
}

Time Complexity increasing by n^(1/3)log(n)

Sun, 04 Mar 2018 17:42:39 +0000

int j = 2
while (j < n) {
    int k = j
    while (k < n) {
        Sum += a[k] * b[k]
        k += n^(1/3) log(n)
    }
    j = j * sqrt(5)
}

From the midterm practice

What's the time complexity when j increases by j += log(j+5)?

Sun, 10 Sep 2017 18:51:36 +0000

Consider the following code:

int j = 1;

while (j < n) {

j += log( j + 5 )

}

How to calculate the time complexity?

Time Complexity Analysis - Nested Loops - Inner Increments by sqrt(k)

Wed, 12 Jul 2017 17:41:00 +0000

What is the time complexity of this algorithm:

j = 1
while (j < n) {
   k = j
   while (k < n){
      sum += a[k]*b[k]
      k += sqrt(k)
  }
  j += 0.25*n
}

log(n!) = Theta(nlogn)

Wed, 10 May 2017 03:31:10 +0000

How to explain this equation? It seems to be clear that log(n!) = O(n log n), since log (1.2.3.4.5....n) <= log (n.n.n.n...n) (n times).

However, how do we prove that log (n!) = Omega (n log n)

Solve the recurrence relation: T(n)=T(n/2)+T(n^0.5)+n

Thu, 02 Mar 2017 21:04:44 +0000

How to get the time complexity of these algorithms, in terms of n in quiz 2?

Sat, 18 Feb 2017 20:13:03 +0000

Question 1

j= 2
while (j < n) { 
    k=2
    while (k < n) { 
        sum += a[k]*b[k] 
        k = k * sqrt(k)
    } 
  j += 5*j/3
}

Question 2

for (int j = 1 to n)  {
    int k = j 
    while (k < n) {
        Sum += a[k]*b[k]
        k += n^(1/3) 
    }
}

Solve the recurrence Relation T(n)=T(n/5)+T(7n/10)+(n^2)

Wed, 08 Feb 2017 22:40:39 +0000

The executive time of program in eclipse seems to be randomly when the times are not very large

Mon, 23 Jan 2017 02:57:54 +0000

public class test2 {
    public static void main(String []args){
          long start = System.nanoTime();
          double j = 2;
          double n = 100000000;
          int count1 = 0;
          int count3 = 0;
          while (j < n) {
            double k = 2;
            int count2 = 0;
            count1++;
            //System.out.println("first while loop for " + count1 + " times");
            while (k < n) {
              k = k * k;
              count2++;
              count3++;
            }
            j += j/2;
            System.out.println("second while loop for " + count2 + " times");
        }
        System.out.println("total loop for " + count3 + " times");
        long end = System.nanoTime();
        System.out.println("TimeCost: " + (end - start) + " NS");
      }
}

This is the program I wrote to test its executive time. I add System.nanoTime() to record the time. But when the times are not very large, like 50 or 200 times, by changing the value of n, the executive time of 200 times sometimes is shorter than that of 50 times. However, when the times are added to like 10000000, it obviously takes longer time. I wonder if there is another way to measure the executive time of program more accurately.

Loop i through log n incremented by constant multiplication

Mon, 05 Dec 2016 01:52:40 +0000

What is the time complexity of the following loop?

double j = 1.0
while (j < log n) {
    j = 1.3 * j
}

The loop, if it was j < n, then it would be log n. However, it goes from j = 1 to log n instead of n. How do you combine that to find the total complexity?

Time Complexity - Recursive function - Two recursive calls, and double nested loop

Wed, 05 Oct 2016 16:46:20 +0000

function T(int n) {
  int n1 = T((n-1)/4) 
  int n2 = T((n+1)/4)


  int sum = 0 

  for i = 1 to n {
    for j = 1 to n {
      sum+=n1*i + n2*j
    }
  }
  return sum
}

T(n) = ?

Time complexity of recursive function - Single recursive call of size n/3 and n^2 loop

Mon, 03 Oct 2016 15:24:17 +0000

function T(int n) {
  int n1 = 2T(n/3) + 5
  int n2 = 2*n1*n1
  int sum = 0 

  for i = 1 to n {
    for j = 1 to n {
      sum+=n1*i + n2*j
    }
  }
  return sum
}

// Assume T(1) = 1

T(n) = ?

MT for T(n) = 2T(n/2) + n^2 log n

Thu, 22 Sep 2016 15:25:55 +0000

How do we use MT to solve T(n) = 2T(n/2) + n^2 log n?

c = 2 > log_b(a) here, but f(n) = Theta (n^2 log n) instead of purely Theta(n^2).

Besides, for T(n) = 2T(n/2) + n logn, f(n) / n^log_b(a) = log n, there is a non-polynomial difference right? Then why can we use MT for it?

Recurrence relation : T(n) = T(n/3) + 2 T(2n/3) + n

Fri, 16 Sep 2016 00:44:00 +0000

Solve the recurrence relation:T(n)=T(n/3)+2T(2n/3)+n.

Prove Ө(log 1 + log2 + log3 + log4 +... + logn) = Ө(n log n)

Thu, 15 Sep 2016 20:12:54 +0000

Prove Ө(log2 *log3 *log4 *...*logn) = Ө(n log n)

That is, prove both the the big Oh and big Omega side.

For-While Nested Loops Time Complexity - Inner Loop increments by n^1/3

Thu, 15 Sep 2016 06:09:59 +0000

for (int j = 1 to n) {
  int k = j
  while (k < n) {
    Sum += a[k]*b[k]
    k += n^1/3
  }
}

For this one I came across the answer of O(n^2) but the answer key was n^5/3

Anyone can explain when we can ignore the constants? Thx

Given f(n) = o(g(n)), prove that 2^f(n) = o(2^g(n))

Mon, 12 Sep 2016 21:27:35 +0000

Given f(n) = o(g(n)), prove that 2^f(n) = o(2^g(n))

Given f(n) = o(g(n)), show that it is not necessary that log (f(n)) = o(log (g(n)))

Mon, 12 Sep 2016 20:39:25 +0000

Given f(n) = o(g(n)), show that it is not necessary that log (f(n)) = o(log (g(n)))

[Hint, use a counterexample]

Count Primes - Time Complexity

Sun, 11 Sep 2016 06:47:05 +0000

What is the time complexity of this algorithm, in terms of n?

public int countPrimes(int n) {
boolean[] isPrime = new boolean[n];
for (int i = 2; i < n; i++) {
isPrime[i] = true;
}

// Loop's ending condition is i * i < n instead of i < sqrt(n)
// to avoid repeatedly calling an expensive function sqrt().
for (int i = 2; i * i < n; i++) {
if (!isPrime[i]) continue;
for (int j = i * i; j < n; j += i) {
isPrime[j] = false;
}
}
int count = 0;
for (int i = 2; i < n; i++) {
if (isPrime[i]) count++;
}
return count;
}

Credit: https://leetcode.com/problems/count-primes/

Compare 2^n^2 and 10^n asymptotically

Sat, 10 Sep 2016 22:16:07 +0000

Prove that 10ⁿ = o(2^{n^2})

Order these time complexities from best (lowest) to worst (highest)

Thu, 01 Sep 2016 02:22:55 +0000

O(n)

O(n²)

O(n³)

O(log n^ log n)

O(log log n ^ log log n)

O(log n ^ log log n)

Time Complexity Analysis - Double Loop - Second increments by 0.01

Sat, 20 Aug 2016 20:00:28 +0000

What is the time complexity of the following program?

for (int j = 1 to n) {
  int k = j
  while (k < n) {
    Sum += a[k]*b[k]
    k += 0.01 * n
  }
}

Asymptotic Analysis - Triple Loop - k starts from j^2

Sat, 02 Jul 2016 12:50:03 +0000

What is the time complexity of this program?

for i = 1 to n

    for j = i to n

      for k = j*j to n

         sum++;

Trichotomy in Context of Asymptotic Functions

Fri, 29 Jan 2016 13:00:46 +0000

Given two functions f(n) and g(n), both strictly increasing with n, is it possible that f(n) and g(n) cannot be compared asymptotically? Either prove that such two functions can always be compared asymptotically, or give a counter example, such that neither f(n) is in O(g(n)) nor is g(n) in O(f(n)).

Time Complexity Analysis - Odd Even - Big Jumps

Tue, 19 Jan 2016 17:30:01 +0000

j = 1
while ( j < n ) {
     k = j
     while ( k < n ) {
          If  ( k is odd )
              k++
          else   
              k + = 0.01 * n
    }
    j+=0.1*n
}

Time Complexity Analysis - 2 (2nd by log n)

Tue, 19 Jan 2016 16:24:13 +0000

for (int j=1 to n) {
   k=j;
   while (k<n) {
       Sum += a[k]*b[k];
       k += logn;
    }
}

Time Complexity Analysis - Inner loop var gets squared

Fri, 15 Jan 2016 11:13:41 +0000

j = 1
while (j < n) {
  k = 2
  while (k < n) {
    Sum += a[j]*b[k]
    k = k * k
  }
  j++
}

Time complexity of GCD algorithm

Fri, 15 Jan 2016 00:20:21 +0000

gcd(n,m) {
  r = n%m
  if r == 0 return m;
  // else
  return gcd(m, r)
}