complexity-theory

IDictionary<TK, TV> defines method IDictionary.ContainsKey(in TK) and property IDictionary.Keys (of type ICollection ). I'm interested in (asymptotic) complexity of this method and property in Dictionary implementation of IDictionary<TK, TV> . Consider definitions IDictionary<int, string> dict = new Dictionary<int, string>(); int k = new Random().Next(); and consider that we have added to the dictionary dict n unique KeyValuePair s. What is expected (asymptotic) complexity of a call dict.ContainsKey(k) ? I hope it's in O(1) but I did not find it in documentation of Dictionary.ContainsKey .

A list of n strings each of length n is sorted into lexicographic order using the merge sort algorithm. The worst case running time of this computation is? I got this question as a homework. I know merge sort sorts in O(nlogn) time. For lexicographic order for length in is it n times nlogn ? or n^2 ? amit Each comparison of the algorithm is O(n) [comparing two strings is O(n) worst case - you might detect which is "bigger" only on the last character], You have O(nlogn) comparisons in mergesort. Thus you get O(nlogn * n) = O(n^2 * logn) But according to the recurrence relation T(n) = 2T(n/2) +

I am new in the algorithm analysis domain. I read here in the Stack Overflow question " What is a plain English explanation of "Big O" notation? " that O(2n^2) and O(100 n^2) are the same as O(n^2) . I don't understand this, because if we take n = 4, the number of operations will be: O(2 n^2) = 32 operations O(100 n^2) = 1600 operations O(n^2) = 16 operations Can any one can explain why we are supposed to treat these different operation counts as equivalent? Why this is true can be derived directly from the formal definition . More specifically, f(x) = O(g(n)) if and only if |f(x)| <= M|g(x)|

Alright quick overview I have looked into the knapsack problem http://en.wikipedia.org/wiki/Knapsack_problem and i know it is what i need for my project, but the complicated part of my project would be that i need multiple sacks inside a main sack. The large knapsack that holds all the "bags" can only carry x amount of "bags" (lets say 9 for sake of example). Each bag has different values; Weight Cost Size Capacity and so on, all of those values are integer numbers. Lets assume from 0-100. The inner bag will also be assigned a type, and there can only be one of that type within the outer bag,

1-)For sorted array I have used Binary Search. We know that the worst case complexity for SEARCH operation in sorted array is O(lg N), if we use Binary Search, where N are the number of items in an array. What is the worst case complexity for the search operation in the array that includes duplicate values, using binary search?? Will it be the be the same O(lg N)?? Please correct me if I am wrong!! Also what is the worst case for INSERT operation in sorted array using binary search?? My guess is O(N).... is that right?? 2-) For unsorted array I have used Linear search. Now we have an unsorted

I have been working all day with a problem which I can't seem to get a handle on. The task is to show that a recursive implementation of edit distance has the time complexity Ω(2 max(n,m) ) where n & m are the length of the words being measured. The implementation is comparable to this small python example def lev(a, b): if("" == a): return len(b) # returns if a is an empty string if("" == b): return len(a) # returns if b is an empty string return min(lev(a[:-1], b[:-1])+(a[-1] != b[-1]), lev(a[:-1], b)+1, lev(a, b[:-1])+1) From: http://www.clear.rice.edu/comp130/12spring/editdist/ I have

We're learning about time complexity right now and I'm having a ton of trouble with this one example. for (i = 2; i < n; i = i * i) { ... do something ... } The prof said that it was O(sqrt(N)), but I'm not sure that I'm convinced. After all, if N=16, it only runs 2 times, not 4 right? My approach to solution: 2^(2k) = N, where k is the number of times the loop runs. Removing the constant factors, k runs log(N) times. Where am I going wrong here? Thanks for any advice on the matter. You are correct that your instructor is wrong (at least, their bound isn't tight), and I like the analysis you