recurrence

I've been looking at this reccurrence and wanted to check if I was taking the right approach. T(n) = T(n^(1/2)) + 1 = T(n^(1/4)) + 1 + 1 = T(n^(1/8)) + 1 + 1 + 1 ... = 1 + 1 + 1 + ... + 1 (a total of rad n times) = n^(1/2) So the answer would come to theta bound of n^(1/2) hint: assume n = 2 2 m or m = log 2 log 2 n, and you know 2 2 m-1 * 2 2 m-1 = 2 2 m so, if you define S(m)=T(n) your S will be: S(m) = S(m-1)+1 → S(m) = Θ(m) → S(m)=T(n) = Θ(log 2 log 2 n) extend it for the general case. In recursion like T(n) = T(n/2) + 1, in each iteration, we reduce the height of the tree to half. This

Started learning algorithms. I understand how to find theta-notation from a 'regular recurrence' like T(n) = Tf(n) + g(n) . But I am lost with this recurrence: problem 1-2e : T(n) = T(√n) + Θ(lg lg n) How do I choose the method to find theta? And what, uh, this recurrence is? I just do not quite understand notation-inside-a-recurrence thing. One trick that might useful would be to transform n into something else, like, say, 2 k . If we do this, you can rewrite the above as T(2 k ) = T(2 k/2 ) + Θ(log log 2 k ) = T(2 k ) = T(2 k/2 ) + Θ(log k) Now this looks like a recurrence that we might

I am trying to solve this recurrence T(n) = 3 T(n/2) + n lg n .. I have come to the solution that it belongs to masters theorem case 2 since n lg n is O(n^2) but after referring to the solution manual i noticed this solution that they have The soluttion says that n lg n = O ( n ^(lg 3 - e)) for e between 0 and 0.58 so this means n lg n is O(n) .. is this right? Am i missing something here? Isn't nlgn O(n^2) ? This will explain things better n*log(n) is not O(n^2) . It's known as quasi-linear and it grows much slower than O(n^2) . In fact n*log(n) is less than polynomial. In other words: O(n

I am building a calendar website ( ASP.NET MVC ) application (think simple version of outlook) and i want to start supporting calendar events that are recurring (monthly, yearly, etc) right now I am storing actual dates in my but I wanted to figure out if, with recurrence, does it make sense to continue to store dates (with some obvious cutoff), or should I store the recurrence options and generate the dates on the fly. It got me thinking how outlook, google mail, etc does this or any other service that supports recurring calendar items. Are there any suggestions on this? Separate your data

I have the following worked out: T(n) = T(n - 1) + n = O(n^2) Now when I work this out I find that the bound is very loose. Have I done something wrong or is it just that way? Think of it this way: In each "iteration" of the recursion you do O(n) work. Each iteration has n-1 work to do, until n = base case. (I'm assuming base case is O(n) work) Therefore, assuming the base case is a constant independant of n, there are O(n) iterations of the recursion. If you have n iterations of O(n) work each, O(n)*O(n) = O(n^2). Your analysis is correct. If you'd like more info on this way of solving

I'm really trying to wrap my brain around how recursion works and understand recursive algorithms. For example, the code below returns 120 when I enter 5, excuse my ignorance, and I'm just not seeing why? def fact(n): if n == 0: return 1 else: return n * fact(n-1) answer = int (raw_input('Enter some number: ')) print fact(answer) lets walk through the execution. fact(5): 5 is not 0, so fact(5) = 5 * fact(4) what is fact(4)? fact(4): 4 is not 0, so fact(4) = 4 * fact(3) what is fact(3)? fact(3): 3 is not 0, so fact(3) = 3 * fact(2) what is fact(2)? fact(2): 2 is not 0, so fact(2) = 2 * fact(1)

I'm building a group calendar application that needs to support recurring events, but all the solutions I've come up with to handle these events seem like a hack. I can limit how far ahead one can look, and then generate all the events at once. Or I can store the events as repeating and dynamically display them when one looks ahead on the calendar, but I'll have to convert them to a normal event if someone wants to change the details on a particular instance of the event. I'm sure there's a better way to do this, but I haven't found it yet. What's the best way to model recurring events, where