22

I've written a brute force search algorithm for the travelling salesman problem, and tested it to see the time it takes for various numbers of 'cities'. From the graph below, we can see that the time is roughly proportional to (n-1)! where n is the number of 'cities'. It is not directly proportional to n! (after all, (n-1)! = n! / n).

My question is, is it still correct to say that the algorithm runs in O(n!), or is it better for me to say O((n-1)!)? I've never seen the latter before, but it seems more accurate. It seems that I've misunderstood something here.

[t = time taken, n = number of cities]

user
  • 6,897
  • 8
  • 43
  • 79
laurencevs
  • 923
  • 8
  • 20
  • 5
    Possible duplicate of [Which Big-O grows faster asymptotically](http://stackoverflow.com/questions/35000930/which-big-o-grows-faster-asymptotically) – Idos Sep 05 '16 at 13:28
  • The Big-O notation is not meant to actually provide a calculation of an algorithm, but rather to provide an abstract means of comparison between them. The end-behavior of your algorithm is a factorial - the fact that it happens to be +1 or -1 is immaterial. – iAdjunct Sep 06 '16 at 04:02

4 Answers4

52

By definition, O(f(n)) is the set of all functions that are asymptotically dominated by f(n), i.e. the set of all functions g(n) for which there are constants C and n_0 such that

g(n) < C * f(n)   for all n > n_0

From this definition, it follows that O(n!) is actually a superset of O((n-1)!), since the function f(n) = n! is a member of the first set, but not of the second set. The two sets aren't actually the same.

It is correct, though, to say that your problem is O(n!), since this only states an upper boundary. It would not be correct to say that your problem is ϴ(n!), since this denotes the exact asymptotic behaviour up to constant factors.

There is no big difference in practice, and, as noted in another answer, you can redefine n to mean the number of cities minus one.

Sven Marnach
  • 574,206
  • 118
  • 941
  • 841
  • This answer uses the correct approach. Indeed, often one has `O(f(n)) = O(f(n-1))` -- this is true if `f` is a polynomial or an exponential, for instance. However, as pointed above, this is not true for all functions: we have `lim n!/(n-1)! = lim n = infty` for `n -> infty`. – chi Sep 05 '16 at 12:08
  • 5
    Right. I wouldn't quite agree with “there's no big difference in practice” between `f(n)` and `f(n-1)` – not when the function grows as fast as the factorial! IOW, one can say any Θ (_n_!) algorithm is only usable for really small inputs; you never get a chance to make `n` so big that one more or less would be insignificant. – leftaroundabout Sep 05 '16 at 12:13
  • "you can redefine n to mean the number of cities minus one." Which is a bad idea as this would lead to confusion. Why not defining it as sqrt(|cities|)? – FooTheBar Sep 05 '16 at 16:25
7

O(n!) is good enough. n or n-1 makes no difference for large n.

See https://www.wikiwand.com/en/Time_complexity#/Table_of_common_time_complexities for examples.

Bartosz Bilicki
  • 12,599
  • 13
  • 71
  • 113
  • 4
    Say, a large value is `n=100`, then `O(n!)=9.33*10^157` , where `O((n-1)!)=9.33*10^155`. Do you think there is no difference between this two?? :) – jbsu32 Sep 05 '16 at 10:41
  • 24
    Both of them are 'big like hell and non usable for large n anyway'. So, no difference indeed :) Both numbers are bigger than estimated number of atoms in the universe (which is mere 10^81).. – Bartosz Bilicki Sep 05 '16 at 10:44
  • 2
    `Both of them are 'big like hell and non usable for large n anyway'` - That does never mean they don't have any difference :D – jbsu32 Sep 05 '16 at 10:47
  • Again, according to your `big like hell and non usable for large n anyway` logic, say `n=11`; `O(n!)=39916800` & `O((n-1)!)=3628800`! I'm afraid if you're now going to say `39.9 million` & `3.6 million` has no difference :D :D – jbsu32 Sep 05 '16 at 10:51
  • 1
    There is difference indeed. No point denying that. But that numeric difference makes no practical difference. Point of O(n) notation is 'limiting behavior of a function when the argument tends towards a particular value or infinity.'. And for O(n!) that (n-1) makes not much of practical difference. For big n, algorithm will not finish between end of universe anyway:) – Bartosz Bilicki Sep 05 '16 at 10:55
  • 1
    O(n) is to be used for big n. 11 or 12 is not big. To lesser degree, same logic applies to other common complexities. – Bartosz Bilicki Sep 05 '16 at 10:56
  • 19
    @jbsu32, that is just nonsense. `O(...)` is a class of functions and can't be equal to a number. And yes, `O(10n) = O(n)`, so there is no difference between `39.9 million` and `3.6 million` for `O`-notation. –  Sep 05 '16 at 10:57
  • Then you accept that `O(n!)` & `O((n-1)!)` makes big difference for small values like `n=11`?? :) – jbsu32 Sep 05 '16 at 10:58
  • 1
    Of course! It makes difference for all n values. For big n, difference is even bigger. – Bartosz Bilicki Sep 05 '16 at 11:00
  • Well, then you have already accepted that you answer is wrong :) @BartoszBilicki – jbsu32 Sep 05 '16 at 11:01
  • if `n=10` then `O(10n)` is never equal to `O(n)` :) @deniss – jbsu32 Sep 05 '16 at 11:03
  • 5
    @jbsu32, `O(f(n))` is a *class of functions*, like even or differentiable functions. What exactly belongs to this class explained by Sven (or in a math book). And if we treat class as a set of all functions belonging to this class (common conception), then yes, `O(10n) = O(n) = O(10^100n)` as their elements are the same. –  Sep 05 '16 at 11:14
  • 6
    @jbsu32, O(10n) is always equal to O(n), because we don't care about constant factor – Adam Stawicki Sep 05 '16 at 11:18
  • 1
    Weirdly enough I asked the same question..Almost http://stackoverflow.com/questions/35000930/which-big-o-grows-faster-asymptotically – Idos Sep 05 '16 at 13:28
  • 1
    I feel like this answer is writing `O(n!)` when it's *thinking* `exp(O(log n!))`. –  Sep 05 '16 at 14:31
  • @jbsu32 It's true, the numbers are not equal. But 60! and 59! are that big that nobody cares at all about their difference, even though n!-(n-1)!~n!. Their values are very different, but the meaning is very same. – Crowley Sep 05 '16 at 16:08
1

You could simply prove as:

O((n-1)!) means there is constant c such as:

algorithm steps(or else time complexity) < c (n-1)! < c n!/n < c n! for every n>1 .

So since your for algorithm complexity function holds: algorithm steps(or else time complexity)

your algorithm is also O(n!).

So we proved that if the time complexity of your algorithm is O((n-1)!) then it is also O(n!).

coder
  • 12,832
  • 5
  • 39
  • 53
1

Sven Marnach's answer is a really good one, I just want to elaborate a bit on this part:

or is it better for me to say O((n-1)!)?

As others have said, O(n) is usually good enough. If you do want to find out more about the problem, you can try to find and prove:

  • A lower bound (usually denoted by Ω(n))
  • A tight upper bound

A lower bound basically says that, under certain asymptions, there can be no algorithm solving the problem asymptotically faster. A tight upper bound is an upper bound that matches a lower bound, i.e., you'd have to prove a lower bound of Ω(f(n)) and an upper bound of O(f(n)). If you can prove a lower bound and a tight upper bound, it means that your algorithm is an asymptotically optimal algorithm for the problem.

To give a concrete example for this: You surely know sorting algorithms like merge sort or quick sort and their upper bound of O(n log n)). Donald Knuth showed (decades ago) that comparison based sorting algorithms for integers require at least n log n comparisons, that is, Ω(n log n) operations. Since we have a matching upper bound, both merge sort and quick sort are said to be asymptotically optimal (although their performance differs a lot in practice).

mort
  • 12,988
  • 14
  • 52
  • 97