complexity-theory

According to this page , I can achieve constant time insertion if I use iterator std::set::insert ( iterator position, const value_type& x ); and the position iterator I provide directly "precedes" the proper (in-order) insertion point. Now the case I'm concerned with is if I know that the value I'm inserting goes at the end (since it's the largest), e.g.: set<int> foo = {1, 2, 3}; foo.insert(4); // this is an inefficient insert According to the above criterion I should pass the last element foo.end()-1 to insert not foo.end() . Is my understanding correct? What happens if I pass foo.end() ?

In short, I need a fast algorithm to count how many acyclic paths are there in a simple directed graph. By simple graph I mean one without self loops or multiple edges. A path can start from any node and must end on a node that has no outgoing edges. A path is acyclic if no edge occurs twice in it. My graphs (empirical datasets) have only between 20-160 nodes, however, some of them have many cycles in them, therefore there will be a very large number of paths, and my naive approach is simply not fast enough for some of the graph I have. What I'm doing currently is "descending" along all

I often here people talk about Big O which measures algorithms against each other Does this measure clock cycles or space requirements. If people want to contrast algorithms based on memory usage what measure would they use If someone says "This algorithm runs in O(n) time", he's talking about speed. If someone says "This algorithm runs in O(n) space", he's talking about memory. If he just says "This algorithm is O(n)", he's usually talking about speed (though if he says it during a discussion about memory, he's probably talking about memory). If you're not sure which one someone's talking

We are to solve the recurrence relation through repeating substitution: T(n)=T(n-1)+logn I started the substitution and got the following. T(n)=T(n-2)+log(n)+log(n-1) By logarithm product rule, log(mn)=logm+logn, T(n)=T(n-2)+log[n*(n-1)] Continuing this, I get T(n)=T(n-k)+log[n*(n-1)*...*(n-k)] We know that the base case is T(1), so n-1=k -> k=n+1, and substituting this in we get T(n)=T(1)+log[n*(n-1)*...*1] Clearly n*(n-1)*...*1 = n! so, T(n)=T(1)+log(n!) I do not know how to solve beyond this point. Is the answer simply O(log(n!)) ? I have read other explanations saying that it is Θ(nlogn)

I am watching the Berkley Uni online lecture and stuck on the below. Problem : Assume you have a collection of CD that is already sorted. You want to find the list of CD with whose title starts with "Best Of." Solution : We will use binary search to find the first case of "Best Of" and then we print until the tile is no longer "Best Of" Additional question : Find the complexity of this Algorithm. Upper Bound : Binary Search Upper Bound is O(log n), so once we have found it then we print let say k title. so it is O(logn + k) Lower Bound : Binary Search lower Bound is Omega(1) assuming we are

Just wondering how much people log within their applications??? I have seen this: "I typically like to use the ERROR log level to log any exceptions that are caught by the application. I will use the INFO log level as a "first level" debugging scheme to show whenever I enter or exit a method. From there I use the DEBUG log level to trace detailed information. The FATAL log level is used for any exceptions that I have failed to catch in my web based applications." Which had this code sample with it: Public Class LogSample Private Shared ReadOnly Log As log4net.ILog = log4net.LogManager