complexity-theory

Given this algorithm (a>0, b>0) : while(a>=b){ k=1; while(a>=k*b){ a = a - k*b; k++; } } My question : I have to find the time complexity of this algorithm and to do so, I must find the number of instructions but I couldn't find it. Is there a way to find this number and if not, how can I find its time complexity ? What I have done : First of all I tried to find the number of iterations of the first loop and I found a pattern : a_i = a - (i(i+1)/2)*b where i is the number of iterations. I've spent hours doing some manipulations on it but I couldn't find anything relevant (I've found weird

foo = [] i = 1 while i < n: foo= foo + ["a"] i*=2 What is the time complexity of this code? My thoguht is: the while loop does log(n) iteration. For each iteration new list is created. So, the total time complexity is: O(log^2(n)). Am I right? The while loop iterates log(n) times. foo + ["a"] : Create a new list by copying the original list. According to Time Complexity - Python Wiki , copying a list take O(n). Time complexity => 1 + 2 + 3 + ... + log(n) => (log(n) + 1) * log(n) / 2 => O(log 2 n) I ran a timeit : (CPython 2.7.5 64bit, Windows 7) def f(n): foo = [] i = 1 while i < n: foo = foo

I am trying to get the correct Big-O of the following code snippet: s = 0 for x in seq: for y in seq: s += x*y for z in seq: for w in seq: s += x-w According to the book I got this example from (Python Algorithms), they explain it like this: The z-loop is run for a linear number of iterations, and it contains a linear loop, so the total complexity there is quadratic, or Θ(n 2 ). The y-loop is clearly Θ(n). This means that the code block inside the x-loop is Θ(n + n 2 ). This entire block is executed for each round of the x-loop, which is run n times. We use our multiplication rule and get Θ(n

I know various algorithms to compute the maximum weighted matching of weighted, undirected bipartite graphs (i.e. the assignment problem): For instance ... The Hungarian Algorithm, Bellman-Ford or even the Blossom algorithm (which works for general, i.e. not bipartite, graphs). However, how can I compute the maximum weighted matching if the edges of the bipartite graph are weighted and directed ? I would appreciate pointers to algorithms with polinomial complexity or prior transformations to make the graph undirected so that I could apply any of the aforementioned algorithms. Edit: note that