Given..
T(0) = 3 for n <= 1
T(n) = 3T(n/3) + n/3 for n > 1
So the answer's suppose to be O(nlogn).. Here's how I did it and it's not giving me the right answer:
T(n) = 3T(n/3) + n/3
T(n/3) = 3T(n/3^2) + n/3^2
Subbing this into T(n) gives..
T(n) = 3(3T(n/3^2) + n/3^2) + n/3
T(n/3^2) = 3(3(3T(n/3^3) + n/3^3) + n/3^2) + n/3
Eventually it'll look like..
T(n) = 3^k (T(n/3^k)) + cn/3^k
Setting k = lgn..
T(n) = 3^lgn * (T(n/3^lgn)) + cn/3^lgn
T(n) = n * T(0) + c
T(n) = 3n + c
The answer's O(n) though..What is wrong with my steps?
T(n) = 3T(n/3) + n/3
T(n/3) = 3T(n/9) + n/9
T(n) = 3(3T(n/9) + n/9) + n/3
= 9T(n/9) + 2*n/3 //statement 1
T(n/9)= 3T(n/27) + n/27
T(n) = 9 (3T(n/27)+n/27) + 2*n/3 // replacing T(n/9) in statement 1
= 27 T (n/27) + 3*(n/3)
T(n) = 3^k* T(n/3^k) + k* (n/3) // eventually
replace k with log n to the base 3.
T(n) = n T(1) + (log n) (n/3);
// T(1) = 3
T(n) = 3*n + (log n) (n/3);
Hence , O (n* logn)
Eventually it'll look like.. T(n) = 3^k (T(n/3^k)) + cn/3^k
No. Eventually it'll look like
T(n) = 3^k * T(n/3^k) + k*n/3
You've opened the parenthesis inaccurately.
These types of problems are easily solved using the masters theorem. In your case a = b = 3, c = log3(3) = 1 and because n^c grows with the same rate as your f(n) = n/3, you fall in the second case.
Here you have your k=1 and therefore the answer is O(n log(n))
This question can be solved by Master Theorem:
In a recursion form :
where a>=1, b>1, k >=0 and p is a real number, then:
if a > bk, then
if a = bk
a.) if p >-1, then
b.) if p = -1, then
c.) if p < -1, then
3. if a < bk
a.) if p >=0, then
b.) if p<0, then T(n) = O(nk)
So, the above equation
T(n) = 3T(n/3) + n/3
a = 3, b = 3, k =1, p =0
so it fall into 2.a case, where a = bk
So answer will be
O(n⋅log(n))
Related
I don't know how to continue in this recurrence cause I don't see any pattern, any help??
T(n) = 2n + T(n/2)
= 3n + T(n/4)
= 7n/2 + T(n/8)
= 15n/4 + T(n/16)
and so on...
As I understand it's just simple reccurence.
T(n) = 2n + T(n/2)
Your notation can makes someone think different. For me it should be:
T(n) = 2n + T(n/2) ....(1)
T(n/2) = 2(n/2) + T(n/2/2) = n + T(n/4)
T(n) = 2n + n + T(n/4) = 3n + T(n/4) ....(2)
T(n/4) = 2(n/4) + T(n/4/2) = n/2 + T(n/8)
T(n) = 2n + n + n/2 + T(n/8) = 7n/2 + T(n/8) ....(3)
T(n/8) = 2(n/8) + T(n/8/2) = n/4 + T(n/16)
T(n) = 2n + n + n/2 + n/4 + T(n/16) = 15n/4 + T(n/16) ....(4)
T(n/16) = 2(n/16) + T(n/16/2) = n/8 + T(n/32)
T(n) = 15n/4 + n/8 + T(n/32) = 31n/4 + T(n/32) ....(5)
and so on...
This is a usual recurrence relation - if you are a CS student, you will soon know the result by heart.
If you want to find the result by hand, make a geometric sum appears from the recurrence:
T(n) = 2n + n + n/2 + ... + n/2^(k+1) + T(0)
= 2n(1 + 1/2+ ... + 1/2^(k+2)) + T(0)
Where k = INT(log2(n))
You can see a geometric sum of general term 1/2 appears
1 + 1/2 + ... + 1/2^(k+2) = (1 - 1/2^(k+3)) / (1 - 1/2)
Observing that 2^(k+2) = 8 * 2^(log2(n)) = 8n and simplifying
T(n) = 4n + T(0) - 1/2 = Theta(4n)
In addition to the expanding series till T(0) way shown by Alexandre Dupriez, You can also apply master theorem to solve it
For the recurrence equation
T(n) = 2n + T(n/2)
Master Theorem:
For recurrences of form,
T(n) = a T(n/b) + f(n)
where a >= 1 and b > 1
If f(n) is O(nc) then
If c < logba, then T(n) = O(n * logba)
If c = logba, then T(n) = O(nc * log n)
if c > logba, then T(n) = O(nc)
we have a = 1, b = 2, c = 1 and c > logba (case 3)[as c = 1 and log 1 (any base) = 0]
Therefore, T(n) = O (n1)
T(n) = O (n)
I've got to this point 4^logn + 3n[(4/3)^logn -1] and am having trouble finishing it.
Log is base 3.(Wasn't sure how to do subscripts and exponents.)
Thanks .
Masters theorem is general tool for such problems , but if you want the specific solution by substitution then it as follows :
T(n) = 4T(n/3) + n
T(n) = 4(4T(n/9) + n/3) + n = 4^2T(n/9) + (4/3)n + n
T(n) = 4^2(4T(n/27) + n/3^2) + (4/3)n + n = 4^3T(n/27) + (4/3)^2n + (4/3)n + n
T(n) = 4^kT(n/3^k) + (4/3)^(k-1)n + (4/3)^(k-2)n....
boundary condition
n/3^k = 1, k = log3(n)
T(1) = 1
geometric series summation
T(n) = 4^log3(n) + 1((4/3)^log3(n) - 1)/(log3(n)-1)*n
using log rules
T(n) = n^(log3(4)) + n^(1+log3(4/3))/(log3(n)-1) - n/(log3(n)-1)
T(n) = n^(log3(4)) + n^(1+log3(4)-log(3))/(log3(n)-1) - n/(log3(n)-1)
T(n) = n^(log3(4)) + n^(log3(4))/(log3(n)-1) - n/(log3(n)-1)
T(n) = O(n^log3(4))
This is a perfect spot to use the Master Theorem. In your case, we want to write the recurrence in the form
T(n) = aT(n / b) + O(nd).
With your recurrence, you get
a = 4
b = 3
c = 1
Since logba > d, the Master Theorem says that this solves to O(nlog3 4).
Hope this helps!
Need some help on solving this runtime recurrence, using Big-Oh:
T(n) = T(n/2) + T(n/2 - 1) + n/2 + 2
I don't quite get how to use the Master Theorem here
For n big enough you can assume T(n/2 - 1) == T(n/2), so you can change
T(n) = T(n/2) + T(n/2 - 1) + n/2 + 2
into
T(n) = 2*T(n/2) + n/2 + 2
And use Master Theorem (http://en.wikipedia.org/wiki/Master_theorem) for
T(n) = a*T(n/b) + f(n)
a = 2
b = 2
f(n) = n/2 + 2
c = 1
k = 0
log(a, b) = 1 = c
and so you have (case 2, since log(a, b) = c)
T(n) = O(n**c * log(n)**(k + 1))
T(n) = O(n * log(n))
Can someone please help me with this ?
Use iteration method to solve it. T(n) = T(n-1) +n
Explanation of steps would be greatly appreciated.
T(n) = T(n-1) + n
T(n-1) = T(n-2) + n-1
T(n-2) = T(n-3) + n-2
and so on you can substitute the value of T(n-1) and T(n-2) in T(n) to get a general idea of the pattern.
T(n) = T(n-2) + n-1 + n
T(n) = T(n-3) + n-2 + n-1 + n
.
.
.
T(n) = T(n-k) + kn - k(k-1)/2 ...(1)
For base case:
n - k = 1 so we can get T(1)
=> k = n - 1
substitute in (1)
T(n) = T(1) + (n-1)n - (n-1)(n-2)/2
Which you can see is of Order n2 => O(n2).
Expand it!
T(n) = T(n-1) + n = T(n-2) + (n-1) + n = T(n-3) + (n-2) + (n-1) + n
and so on, until
T(n) = 1 + 2 + ... + n = n(n+1)/2 [= O(n^2)]
provided that T(1) = 1
In pseudo code using iteration:
function T(n) {
int result = 0;
for (i in 1 ... n) {
result = result + i;
}
return result;
}
Another solution:
T(n) = T(n-1) + n
= T(n-2) + n-1 + n
= T(n-3) + n-2 + n-1 + n
// we can now generalize to k
= T(n-k) + n-k+1 + n-k+2 + ... + n-1 + n
// since n-k = 1 so T(1) = 1
= 1 + 2 + ... + n //Here
= n(n-1)/2
= n^2/2 - n/2
// we take the dominating term which is n^2*1/2 therefor 1/2 = big O
= big O(n^2)
Easy Method:
T (n) = T (n - 1) + (n )-----------(1)
//now submit T(n-1)=t(n)
T(n-1)=T((n-1)-1)+((n-1))
T(n-1)=T(n-2)+n-1---------------(2)
now submit (2) in (1) you will get
i.e T(n)=[T(n-2)+n-1]+(n)
T(n)=T(n-2)+2n-1 //simplified--------------(3)
now, T(n-2)=t(n)
T(n-2)=T((n-2)-2)+[2(n-2)-1]
T(n-2)=T(n-4)+2n-5---------------(4)
now submit (4) in (2) you will get
i.e T(n)=[T(n-4)+2n-5]+(2n-1)
T(n)=T(n-4)+4n-6 //simplified
............
T(n)=T(n-k)+kn-6
**Based on General form T(n)=T(n-k)+k, **
now, assume n-k=1 we know T(1)=1
k=n-1
T(n)=T(n-(n-1))+(n-1)n-6
T(n)=T(1)+n^2-n-10
According to the complexity 6 is constant
So , Finally O(n^2)
I know that
T(n) = T(n/2) + θ(1) can be result to O(Log N)
and my book said this is a case of Binary Search.
But, how do you know that? Is it just by the fact that Binary Search cuts the problem in half each time so it is O(Log N)?
And T(n) = 2T(n/2) + θ(1)
why is it that the result is O(N) and not O(Log N) when the algorithm divides in half each time as well.
Then T(n) = 2T(n/2) + θ(n)
can be result to O(N Log N)? I see the O(N) is from θ(n) and O(Log N) is from T(n/2)
I am really confused about how to determine the Big O of an algorithm that I don't even know how to word it properly. I hope my question is making sense.
Thanks in advance!
an intuitive solution for these problems is to see the result when unfolding the recursive formula:
Let's assume Theta(1) is actually 1 and Theta(n) is n, for simplicity
T(n) = T(n/2) + 1 = T(n/4) + 1 + 1 = T(n/8) + 1 + 1 + 1 = ... =
= T(0) + 1 + ... + 1 [logN times] = logn
T'(n) = 2T'(n/2) + 1 = 2(2T'(n/4) + 1) + 1 = 4T'(n/4) + 2 + 1 =
= 8T'(n/4) + 4 + 2 + 1 = ... = 2^(logn) + 2^(logn-1) + ... + 1 = n + n/2 + ... + 1 =
= 2n-1
T''(n) = 2T(n/2) + n = 2(2T''(n/2) + n/2) + n = 4T''(n/4) + 2* (n/2) + n =
= 8T''(n/8) + 4*n/4 + 2*n/2 + n = .... = n + n + .. + n [logn times] = nlogn
To formally prove these equations, you should use induction. Assume T(n/2) = X, and using it - prove T(n) = Y, as expected.
For example, for the first formula [T(n) = T(n/2) + 1] - and assume base is T(1) = 0
Base trivially holds for n = 1
Assume T(n) <= logn for any k <= n-1, and prove it for k = n
T(n) = T(n/2) + 1 <= (induction hypothesis) log(n/2) + 1 = log(n/2) + log(2) = log(n/2*2) = log(n)
I find an easy way to understand these is to consider the time the algorithm spends on each step of the recurrence, and then add them up to find the total time. First, let's consider
T(n) = T(n/2) + O(1)
where n=64. Let's add up how much the algorithm takes at each step:
T(64) = T(32) + 1 ... 1 so far
T(32) = T(16) + 1 ... 2 so far
T(16) = T(08) + 1 ... 3 so far
T(08) = T(04) + 1 ... 4 so far
T(04) = T(02) + 1 ... 5 so far
T(02) = T(01) + 1 ... 6 so far
T(01) = 1 ... 7 total
So, we can see that the algorithm took '1' time at each step. And, since each step divides the input in half, the total work is the number of times the algorithm had to divide the input in two... which is log2 n.
Next, let's consider the case where
T(n) = 2T(n/2) + O(1)
However, to make things simpler, we'll build up from the base case T(1) = 1.
T(01) = 1 ... 1 so far
now we have to do T(01) twice and then add one, so
T(02) = 2T(01) + 1 ... (1*2)+1 = 3
now we have to do T(02) twice, and then add one, so
T(04) = 2T(02) + 1 ... (3*2)+1 = 7
T(08) = 2T(04) + 1 ... (7*2)+1 = 15
T(16) = 2T(08) + 1 ... (15*2)+1 = 31
T(32) = 2T(16) + 1 ... (32*2)+1 = 63
T(64) = 2T(32) + 1 ... (65*2)+1 = 127
So we can see that here the algorithm has done 127 work - which is equal to the input multiplied by a constant (2) and plus a constant (-1), which is O(n). Basically this recursion corresponds to the infinite sequence (1 + 1/2 + 1/4 + 1/8 + 1/16) which sums to 2.
Try using this method on T(n) = 2T(n/2) + n and see if it makes more sense to you.
One visual solution to find the T(n) for a recursive equation is to sketch it with a tree then:
T(n) = number of nodes * time specified on each node.
In your case T(n) = 2T(n/2) + 1
I write the one in the node itself and expand it to two node T(n/2)
Note T(n/2) = 2T(n/4) + 1, and again I do the same for it.
T(n) + 1
/ \
T(n/2)+1 T(n/2)+1
/ \ / \
T(n/4)+1 T(n/4)+1 T(n/4)+1 T(n/4)+1
... ... .. .. .. .. .. ..
T(1) T(1) .......... ............T(1)
In this tree the number of nodes equals
2*height of tree = 2*log(n) = n
Then T(n) = n * 1 = n = O(n)