complexity-theory

I'm trying to improve the speed of an algorithm and, after looking at which operations are being called, I'm having difficulty pinning down exactly what's slowing things up. I'm wondering if Python's deepcopy() could possibly be the culprit or if I should look a little further into my own code. Looking at the code (you can too), it goes through every object in the tree of referenced objects (e.g. dict's keys and values, object member variables, ...) and does two things for them: see if it's already been copied, by looking it in id-indexed memo dict copy of the object if not The second one is O

I am solving this recurrence using a recursion tree. The total cost of each level is n, and the depth of the tree is between log (n) base 4 and log (n) base 4/3 . Intuitively, I expect the solution to be at most the number of levels times the cost at each level. O(cn log (n) base 4/3) = O(n log n) . I was wondering if my approach towards the problem, and my solution is correct? Think of it this way: for the first log 4 n layers of the recursion tree, the sum of the work across those layers will be cn, because if you sum up the total sizes of all the subproblems, it should total n so the total

So my question is in topic's name. Does exists an algorithm that checks if B is subsequence of A faster, than O(N^2), for example O(NlogN) or simply O(N)? Only way found is simple brut-force for(int i = 0; i < a.Length - b.Length; i++) { if (IsSubsequence(a,b,i)) return i; } return -1; Here's a recursive characterization of David Eisenstat's algorithm. (Note that this algorithm is tail recursive and can therefore be written as a loop; I describe it as recursive because doing so is a nice way to understand the algorithm.) Define a sequence as either empty, or an item followed by a sequence.

I have a string, and another text file which contains a list of strings. We call 2 strings "brotherhood strings" when they're exactly the same after sorting alphabetically. For example, "abc" and "cba" will be sorted into "abc" and "abc", so the original two are brotherhood. But "abc" and "aaa" are not. So, is there an efficient way to pick out all brotherhood strings from the text file, according to the one string provided? For example, we have "abc" and a text file which writes like this: abc cba acb lalala then "abc" , "cba" , "acb" are the answers. Of course, "sort & compare" is a nice try

for example, say n = Integer.MAX_VALUE or 2^123 then O(log(n)) = 32 and 123 so a small integer. isn't it O(1) ? what is the difference ? I think, the reason is O(1) is constant but O(log(n)) not. Any other ideas ? If n is bounded above, then complexity classes involving n make no sense. There is no such thing as "in the limit as 2^123 approaches infinity", except in the old joke that "a pentagon approximates a circle, for sufficiently large values of 5". Generally, when analysing the complexity of code, we pretend that the input size isn't bounded above by the resource limits of the machine,

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center . Closed 6 years ago . Can anyone suggest me a worst case "text string - pattern pair" for testing a KMP algorithm implementation? I would say a pattern like xx........x | n times | and a string like xxx.........xyx...........xy.... | n-1 times | | n-1 times | would be one of the worst cases, but it's still O(m+n) You can find anything