Algorithms Q&A - Recent questions and answers in Asymptotic Analysis

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

Thu, 12 Dec 2024 07:30:05 +0000

For the innermost loop to execute, the condition j²≤ n must hold, meaning j ≤ n^0.5.

In the middle loop, j ranges from i² to n. Since j ≤ n^0.5, the range for j is from i² to n^0.5. For the middle loop to run, the condition i²≤ n^0.5 must be satisfied, which implies i ≤ n^0.25.

Therefore, the outer loop runs from i = 1 to i = n^0.25.

Thus, the total time complexity is n^0.25⋅n^0.5⋅n = O(n^1.75) or O(n^7/4).

Answered: Analyze Double Loop - j starts from i*i

Fri, 22 Nov 2024 15:12:26 +0000

This is explained here: https://www.youtube.com/watch?v=tngRU1Mp8M0

Answered: Highest sum of tree heights when one recoloring is allowed

Fri, 22 Dec 2023 17:32:51 +0000

1.Initialization:
Make an array color_heights to hold the total height for each colour. Set current_height and maximum_height to zero.

2.Iteration
Using a sliding window method, begin iterating through the trees.
Create two pointers, one to the left and one to the right, both pointing to the first tree.

3.Window Expansion:
Increase the right pointer to expand the window to the right.
Add the newly inserted tree to color_heights and current_height.

4.Recoloring Attempt:
Attempt a recoloring operation for the full window from colour C1 to colour C2.
Correctly update color_heights and current_height.

5. Update Maximum Height:
Update max_height with the new value if the current contiguous height is greater than the      existing max_height.

6. Window Size Control:
If the window size is greater than k, adjust the left cursor to keep the window size constant. Update the outgoing tree's current_height and color_heights.

7. Repeat Iteration:
Repeat steps 3-6 until the right pointer reaches the end of the trees.

8. Result:
The final value of max_height represents the maximum contiguous height achievable after the recoloring operation.

9. Time Complexity:
Because it only iterates through the trees once and the sliding window assures that each tree is considered at most twice, the technique has a time complexity of O(n), where n is the number of trees.

Conclusion:
With a single recoloring operation, the algorithm uses a sliding window approach to maximize the total height of a continuous block of trees. Iterating through the trees, attempting recoloring, and adjusting the maximum height are all part of the step-by-step procedure. The temporal complexity of the algorithm is O(n), where n is the number of trees.

Answered: outer loop until log n, inner loop exponential increase

Mon, 18 Dec 2023 07:29:55 +0000

1. Let the inner loop run x time

Since k = k^1.3 while k < n:

5^{(1.3)^x}= n

log₅n = 1.3^x

x = log_1.3log₅ n

After ignoring the constants, the running time of the inner loop is loglog n

2. Let the outer loop run y time

Since j = 1.3 * j while j < log n:

5 * 1.3^y = log n

1.3^y = (log n) / 5

y = log_1.3 (log n) / 5

After ignoring the constants, the running time of the outer loop is loglog n

3. Since the inner loop runs loglog n times in each iteration of the outer loop, the overall running time is:

loglog n * loglog n = log(log(n)) log(log(n)) = O(log²(log(n)))

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

Tue, 12 Dec 2023 09:19:52 +0000

Using Estimation Method, we get

R(n) = 2T(n/5) + n² & S(n) = 2T(7n/10) + n²

Applying Masters Theorem to both equations, we get

R(n) = O(n²) & S(n) = O(n²)

Hence, the time complexity for T(n) is O(n²).

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

Tue, 12 Dec 2023 08:11:27 +0000

Inner Loop:

k goes till n and increments by n^1/3 in every iteration
k, k+n^1/3, k+n^1/3+n^1/3 ...... k+(n^1/3)x

equating this to n, we get x = O(n^2/3)

Outer Loop:

j goes till n and increments by 1 with every iteration

Therefore, time complexity of the outer loop is O(n).

Time Complexity = n*n^2/3 = n^(1+2/3) = O(n^5/3).

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

Mon, 11 Dec 2023 04:02:37 +0000

Using Masters theorem:

A = 2, B = 2, K = 0.75(power of n)

log 2 (2) > K (Case 1)

T(n) = n ^ log 2 (2) == Theta(n)

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

Sun, 10 Dec 2023 21:54:15 +0000

f(n) = o(g(n)) means 0<= f(n) < g(n) for all n>= n0

as f(n) is always less than g(n) and both are positive

2^f(n) < c. 2^g(n) for all n >= n0 and c is a constant

Therefore we can say that 2^f(n) = o (2^g(n)) when f(n) = o(g(n))

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

Sun, 10 Dec 2023 21:49:07 +0000

log1 + log 2 + log 3 + ...... + log n = log ( 1*2*3 .... *n) = log(n!)

log1 + log 2 + log 3 + ...... + log n <= log n + log n + log n + ..... + log n

<= n log n

log1 + log 2 + log 3 + ...... + log n = O(n log n)

log1 + log 2 + log 3 + ...... + log n >= n/2 log n/2

log1 + log 2 + log 3 + ...... + log n = big-omega(n log n)

so, log1 + log 2 + log 3 + ...... + log n = Theta(n log n)

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

Sat, 09 Dec 2023 18:48:47 +0000

Using masters theorem: a=14 b=4
n^log_4(14) = n^1.9 > n
T(n) = O(n^log_4(14))

Using masters theorem: a=7 b=2
n^log_2(7) = n^2.8 > n
R(n) = O(n^log_2(7))

T(n) = o(R(n) as n^1.9 < n^2.8

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

Sat, 09 Dec 2023 16:43:03 +0000

Let's analyze the time complexity:

1. Outer Loop (j Loop): The loop variable j starts at 1 and increases by 0.1 * sq(n) in each iteration. The number of iterations for the outer loop is approximately 10 * sq(n).

2. Inner Loop (k Loop): This loop runs until k is less than . The increase in k depends on a random condition:

If random() < 0.5, k is doubled.Otherwise, k increases by 1.

The doubling of k will rapidly increase its value, reaching in $O (lo g lo g n)$ steps because doubling represents an exponential growth. The increment by 1 is less significant compared to the doubling and will not dominate the time complexity. Therefore, the average case for the inner loop is dominated by the case where k is doubled, giving us $O (lo g lo g n)$ iterations.

3. Overall Complexity: The total time complexity is the product of the number of iterations of each loop, which gives us:

10 * sq(n) * $(lo g lo g n) = O($ sq(n) * $(lo g lo g n))$

Therefore, the time complexity of the given code can be approximated as $O($ sq(n) * $(lo g lo g n).$

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

Tue, 20 Dec 2022 03:59:53 +0000

lim (n --> infinity) n / 2n tends to 1/2 ; n = theta(2n)

lim (n --> infinity) n / n^2 , it will be 1/n and tends to 0 ; n = o(n^2)

lim (n --> infinity) 2n / n^2 , it will be 1/n and tends to 0 ; 2n = o(n^2)

Answered: Time Complexity 0.25 * n and k +=k

Thu, 02 May 2019 06:19:23 +0000

j=kn

n totally

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

Thu, 02 May 2019 05:32:21 +0000

Since you know the bigger the better, you can be as big as possible. Maybe you can try a few small numbers and then find the law. Hahaha

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

Tue, 08 May 2018 03:12:34 +0000

We can solve this using substitution method.

Claim: T(n) <= c n^2

IH: We assume that claim is true for all values of n < m.

Inductive Step: T(m) = T(m/4) + T(3m/4) + m^2

<= cm^2/16 + c 9 m^2 / 16 + m^2

= cm^2 (1/16 + 9/16 + 1/c)

= c m^2 (10/16 + 1/c)

<= c m^2 as long as 1/c <= 6/16. So, we can choose a value of c >= 16/6 and the rest of the math holds up.

QED.

Therefore, by PMI, T(n) <= c n^2, that is, T(n) = O(n^2).

Alternative Proof:

Follow the same logic, but instead of c, use a larger constant such as 10.

T(n) = 10 n^2/16 + 10 9n^2/16 + n^2.

<= 10 n^2.

Answered: Time Complexity (3 loops with gcd)

Tue, 06 Mar 2018 14:49:31 +0000

Normally, these three loops runs O(n) respectively, making the time complexity O(n²).

However, consider the second loop, where there is

If (gcd(i,j) == 1) {

j = n

}

Then, since there is gcd(i,j) == 1, the loop ends. Since the GCD of any two consecutive integer is 1, the second loop would always ends when j == i + 1. Thus, the second loop runs O(1) times only.

As a result, the time complexity isT(n) = O(n²)

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

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

Outer loop Analysis (for j)

j goes from 2 to n, multiplied by a constant at ever stype

n = (2 * sqrt(5)) * sqrt(5)).... =

Therefore, number of steps = 2log[5,(n/2)] = O(log(n))

Inner loop Analysis (for k) 

n = k * n^(1/3)* log(n)

Number of steps: O(n^(2/3)/log(n))

Overall:

O(log(n) * n^(2/3)/log(n))

= O(n^(2/3))

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

Wed, 13 Sep 2017 10:45:35 +0000

One way to think about this question is to break the range that j starts from and ends at, into two parts:

j starts from 1, reaches n.

Let us break this into two separate journeys:

Part 1: j goes from 1 to sqrt(n)
Part 2: j goes from sqrt(n) to n.

Let us analyze these two separately.

Part 1 - This can not take more than O(sqrt(n)) time
Part 2 - This can not take more than O(n / log (sqrt(n))) time.

We observe that O(n/log (sqrt(n))) = O( 2 n / log n) = O(n / log n) time.

Therefore, total time = O(sqrt(n)) + O(n/log n), that is, O(n/log n)

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

Wed, 12 Jul 2017 21:17:11 +0000

Outer loop runs only 4 times. So, we could just start with the first iteration of the loop where k starts with 1. Needs to get to n. Then we could multiply the answer by 4, and that would be the worst case.

So, effectively, the question is:

// In this code, how many times does the while loop run?
k = 1
while (k < n){
    k += sqrt(k)
}

One can conclude that that only takes THETA(sqrt(n)) time, using two different arguments.

We claim that this must be OMEGA(sqrt(n)), because k needs to go from 1 to n, and it never increments by anything larger than sqrt(n). Therefore, it must require at least sqrt(n) steps.
We claim that this must be BIG OH(sqrt(n)), because of the following:
- Number of steps taken when k goes from n/4 to n is at most 2*sqrt(n) because square root of k is at least sqrt(n) / 2.
- Similarly number of iterations of inner loop, when k moves from n/16 to n/4 = sqrt(n), because square root of k is at least sqrt(n)/4.
- Similarly for k to go from n/64 to n/16 = sqrt(n) / 2
- Summing up all together = sqrt(n) * [ 2 + 1 + 0.5 + 0.25 + .... ] <= 4*sqrt(n)

[Thanks to Piyush Gupta for his suggestion in simplification of big oh analysis.]

Answered: log(n!) = Theta(nlogn)

Thu, 15 Jun 2017 16:57:19 +0000

log(n!) = log(1) + log(2) + ... + log(n-1) + log(n)

You can get the upper bound by

log(1) + log(2) + ... + log(n) <= log(n) + log(n) + ... + log(n)
                                = n*log(n)

And you can get the lower bound by doing a similar thing after throwing away the first half of the sum:

log(1) + ... + log(n/2) + ... + log(n) >= log(n/2) + ... + log(n)
                                       >= log(n/2) + ... + log(n/2)
                                        = n/2 * log(n/2)

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

Mon, 20 Mar 2017 21:25:29 +0000

Simple guess that anyone can make is that T(n) = O(n). This can be proved using PMI.

Further, since T(n) includes n, we know that T(n) = Big Omega(n). Therefore, we can reach the conclusion that T(n) = Theta(n).

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

Tue, 21 Feb 2017 01:23:32 +0000

My answer would be O(logn * log log n) for #1 and O(n^5/3) for #2. I don't know about others, I have an alternative way to quantify time complexity: the total times for executing each line of code.

Explanation:

#1: for the inner loop

while (k < n) {
           Sum += 1;
           k = k * sqrt(k);
       }

How many iterations will be executed depends on value k, in this loop, k starts as 2, goes with 2^3/2, (2^3/2)^3/2, .... , 2^{(3/2)^z}, until it becomes greater than n. the value z here is the times of iteration, assume 2^{(3/2)^z} = n, there exists z = log log n.

For the outer loop,

while (j < n) {
k = 2;
//inner loop, takes log log n

...

j += 5*j/3;
}

Similarly, j starts as 2, goes with 2, 5/3 * 2, (5/3)² * 2, ...., (5/3)^z * 2, until it becomes greater than n. the value z = log_5/3n/2, approximately, log n.

The time complexity of the total algorithm is the product of each loop, which is O(log n * log log n).

#2: I take k += n1/3 as k += n^1/3. Again, for inner loop, k starts as j, goes with j + n^1/3, j + 2 * n^1/3, ... , j + z * n^1/3until it becomes greater than n. (omit constant z) the value z = n^2/3. For the outer loop. j starts as 1 to n, so z = n. For the whole algorithm , it's O(n^5/3).

We can't accurately calculate each algorithm manually, because constant will be omitted during the process, the base number of log will always count as 2, etc. However, we can know the order of magnitude after doing some simple math, which is the meaning of O().

Answered: Loop i through log n incremented by constant multiplication

Mon, 05 Dec 2016 02:37:48 +0000

So let's say there are k steps taken in the program.

1.3^k = log n

k = log_1.3log n

Time complexity is O(loglog n).

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

Sun, 06 Nov 2016 01:57:48 +0000

Please provide more information - at least 12 characters

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.

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
  }
}

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)
}