Examples of higher order algorithms ($\mathcal{O}(n^4)$ or larger)

Question

In most computer science cirriculums, students only get to see algorithms that run in very lower time complexities. For example these generally are

Constant time $\mathcal{O}(1)$: Ex sum of first $n$ numbers
Logarithmic time $\mathcal{O}(\log n)$: Ex binary searching a sorted list
Linear time $\mathcal{O}(n)$: Ex Searching an unsorted list
LogLinear time $\mathcal{O}(n\log n)$: Ex Merge Sort
Quadratic time $\mathcal{O}(n^2)$: Ex Bubble/Insertion/Selection Sort
(Rarely) Cubic time $\mathcal{O}(n^3)$: Ex Gaussian Elimination of a Matrix

However it can be shown that $$ \mathcal{O}(1)\subset \mathcal{O}(\log n)\subset \ldots \subset \mathcal{O}(n^3)\subset \mathcal{O}(n^4)\subset\mathcal{O}(n^5)\subset\ldots\subset \mathcal{O}(n^k)\subset\ldots $$

so it would be expected that there would be more well known problems that are in higher order time complexity classes, such as $\mathcal{O}(n^8)$.

What are some examples of algorithms that fall into these classes $\mathcal{O}(n^k)$ where $k\geq 4$?

This post on cstheory lists algorithms is a ridiculous polynomial. Somewhat orthogonal, but if you look at the problems that come up you'll find examples of those you want. — integrator, Oct 22 '20 at 04:21
Does this answer your question? Decision problems in $\mathsf{P}$ without fast algorithms — Juho, Oct 22 '20 at 11:25
You probably want to use the $\Theta(\cdot)$ or $\Omega(\cdot)$ notation. All the algorithms that you have listed run in time $O(n^8)$. — Steven, Jul 19 '21 at 11:03

score 3 · Answer 1 · edited Jul 19 '21 at 20:12

Brute-force algorithms can be considered as a good example to achieve the mentioned running times (i.e. $\Omega(n^4)$).

Suppose given the sequence $\sigma=\langle a_1,a_2,\dots , a_n\rangle$ of real numbers, you want to find, if exists $k$ elements ($k\geq 4$, and $k$ is constant ) from $\sigma$ such that $$\sum_{i=1}^{k}a_i=0.$$

Obviously, a simple brute-force algorithm for this problem check all $\binom{n}{k}$ subsets of the input and detect whether the elements in at least one of them sum to $0$. If $k$ is a constant then $\binom{n}{k}=\Theta(n^k)$. For example if $k=10$ then the running time of your algorithm is $\Theta(n^{10}).$ Finally, you find algorithm for your desired running time.

score 2 · Answer 2 · answered Oct 22 '20 at 08:49

2

The problem of $1$-processor gap scheduling of $n$ jobs has time complexity $O(n^7)$.

The paper is available here.

answered Oct 22 '20 at 08:49

zdm

1,046
9
15

zkutch · Answer 3 · 2020-10-22T00:01:39.330

1

Most simple example gives nested cycles: we know that, if we want, for example, find similar elements for 2 arrays, then we used 2 nested loops and therefore we have $O(n^2)$ complexity.

Hence, every 4 nested loops gives complexity $O(n^4)$, $k$ nested loops $O(n^k)$.

Another examples Karmarkar's algorithm, AKS primality test

edited Oct 22 '20 at 00:01

answered Oct 21 '20 at 22:26

zkutch

2,364
1
7
14

The AKS primality test is the example I was going to nominate. The more modern versions are $O(n^{6})$. See https://math.dartmouth.edu/~carlp/PDF/complexity12.pdf – Pseudonym Oct 21 '20 at 22:40
Thanks. Brought link is very interesting. – zkutch Oct 21 '20 at 22:45
At n^6 nanoseconds, you could check a 128 bit integer in a good hour. – gnasher729 Jul 19 '21 at 14:10

Examples of higher order algorithms ($\mathcal{O}(n^4)$ or larger)

3 Answers3