complexity-theory

itertools.combinations in python is a powerful tool for finding all combination of r terms, however, I want to know about its computational complexity . Let's say I want to know the complexity in terms of n and r , and certainly it will give me all the r terms combination from a list of n terms. According to the Official document, this is the rough implementation. def combinations(iterable, r): # combinations('ABCD', 2) --> AB AC AD BC BD CD # combinations(range(4), 3) --> 012 013 023 123 pool = tuple(iterable) n = len(pool) if r > n: return indices = list(range(r)) yield tuple(pool[i] for i

Given k sorted arrays of integers, each containing an unknown positive number of elements (not necessarily the same number of elements in each array), where the total number of elements in all k arrays is n, give an algorithm for merging the k arrays into a single sorted array, containing all n elements. The algorithm's worst-case time complexity should be O(n∙log k). Name the k-sorted lists 1, ..., k. Let A be the name of the combined sorted array. For each list, i, pop v off of i and push (i, v) into a min-heap. Now the heap will contain pairs of value and list id for the smallest entries in

I want to understand how to arrive at the complexity of the below recurrence relation. T(n) = T(n-1) + T(n-2) + C Given T(1) = C and T(2) = 2C; Generally for equations like T(n) = 2T(n/2) + C (Given T(1) = C), I use the following method. T(n) = 2T(n/2) + C => T(n) = 4T(n/4) + 3C => T(n) = 8T(n/8) + 7C => ... => T(n) = 2^k T (n/2^k) + (2^k - 1) c Now when n/2^k = 1 => K = log (n) (to the base 2) T(n) = n T(1) + (n-1)C = (2n -1) C = O(n) But, I'm not able to come up with similar approach for the problem I have in question. Please correct me if my approach is incorrect. The complexity is related

Given a random unidirected graph, I must find 'bottleneck edges' to get from one vertex to another. What I call 'bottleneck edges' (there must be a better name for that!) -- suppose I have the following unidirected graph: A / | \ B--C--D | | E--F--G \ | / H To get from A to H independently of the chosen path edges BE and DG must always be traversed, therefore making a 'bottleneck'. Is there a polynomial time algorithm for this? edit: yes, the name is 'minimum cut' for what I meant witch 'bottleneck edges'. Sounds like you need minimum cut, the minimal set of edges removing which will separate