complexity-theory

I have a question that is very similar to algorithm to find longest non-overlapping sequences . The only difference to the linked question is that instead of finding the set of non-overlapping tuples that represent the longest sequence , I need to find the set of non-overlapping tuples that represent the maximum coverage , by which I mean the sum of the tuple lengths is maximum (a tuple length being last - first + 1 given the definition of tuple in the next sentence). I represent my tuples differently than the linked problem. Instead of (starting index, length) , I represent my tuples as

Let's say we have an array of 1.000.000 elements and we go through all of them to check something simple, for example if the first character is "A". From my (very little) understanding, the complexity will be O(n) and it will take some X amount of time. If I add another IF (not else if) to check, let's say, if the last character is "G", how will it change complexity? Will it double the complexity and time? Like O(2n) and 2X ? I would like to avoid taking into consideration the number of calculations different commands have to make. For example, I understand that Len() requires more

Possible Duplicate: Are there any O(1/n) algorithms? This just popped in my head for no particular reason, and I suppose it's a strange question. Are there any known algorithms or problems which actually get easier or faster to solve with larger input? I'm guessing that if there are, it wouldn't be for things like mutations or sorting, it would be for decision problems. Perhaps there's some problem where having a ton of input makes it easy to decide something, but I can't imagine what. If there is no such thing as negative complexity, is there a proof that there cannot be? Or is it just that

While answering to this question a debate began in comments about complexity of QuickSort. What I remember from my university time is that QuickSort is O(n^2) in worst case, O(n log(n)) in average case and O(n log(n)) (but with tighter bound) in best case. What I need is a correct mathematical explanation of the meaning of average complexity to explain clearly what it is about to someone who believe the big-O notation can only be used for worst-case. What I remember if that to define average complexity you should consider complexity of algorithm for all possible inputs, count how many

I understand that the complexity of the clear() operation is linear in the size of the container, because the destructors must be called. But what about primitive types (and POD)? It seems the best thing to do would be to set the vector size to 0, so that the complexity is constant. If this is possible, is it also possible for std::unordered_map? dasblinkenlight It seems the best thing to do would be to set the vector size to 0, so that the complexity is constant. In general, the complexity of resizing a vector to zero is linear in the number of elements currently stored in the vector .

What is the complexity (big-oh) for the remove() function on the Priority Queue class in Java? I can't find anything documented anywhere, I think it's O(n), considering you have to find the element before you remove it and then reshuffle the tree. but I've seen others that disagree and think it's O(logn). Any ideas? The confusion is actually caused by your "remove" function. In java, there are two remove functions. remove() -> This is to remove the head/root, it takes O(logN) time. remove(Object o) -> This is to remove an arbitrary object. Finding this object takes O(N) time, and removing it

Is there a fast algorithm to compute the i-th element (0 <= i < n) of the k-th permutation (0 <= k < n!) of the sequence 0..n-1? Any order of the permutations may be chosen, it does not have to be lexicographical. There are algorithms that construct the k -th permutation in O(n) (see below). But here the complete permutation is not needed, just its i -th element. Are there algorithms that can do better than O(n) ? Is there an algorithm that has a space complexity less than O(n)? There are algorithms that construct the k -th permutation by working on an array of size n (see below), but the