# O que significa um algoritmo mais rápido em ciência da computação teórica?

18

Se existe um algoritmo rodando no tempo $O\left(f\left(n\right)\right)$$O(f(n))$ para algum problema A, e alguém cria um algoritmo rodando no tempo, $O\left(f\left(n\right)/g\left(n\right)\right)$$O(f(n)/g(n))$ , onde $g\left(n\right)=o\left(f\left(n\right)\right)$$g(n) = o(f(n))$ , é considerado uma melhoria em relação ao algoritmo anterior?

Faz sentido, no contexto da ciência da computação teórica, apresentar esse algoritmo?

4
Por "algoritmo mais rápido", queremos dizer "algoritmo assintoticamente mais rápido".
Yuval Filmus

@YuvalFilmus, o que você quer dizer com "assintoticamente"
indefinido

1
Correndo no tempo $o\left(f\left(n\right)\right)$$o(f(n))$ .
Yuval Filmus

Respostas:

26

Não, um algoritmo em execução no tempo , onde , não é necessariamente considerado uma melhoria. Por exemplo, suponha que e . Então $O\left(f\left(n\right)/g\left(n\right)\right)$$O(f(n)/g(n))$$g\left(n\right)=o\left(f\left(n\right)\right)$$g(n) = o(f(n))$$f\left(n\right)=n$$f(n) = n$$g\left(n\right)=1/n$$g(n) = 1/n$ é um período de tempo pior que .$O\left(f\left(n\right)/g\left(n\right)\right)=O\left({n}^{2}\right)$$O(f(n)/g(n)) = O(n^2)$$O\left(f\left(n\right)\right)=O\left(n\right)$$O(f(n)) = O(n)$

Para melhorar um algoritmo rodando no tempo , você precisa criar um algoritmo rodando no tempo , ou seja, no tempo para alguma função $f\left(n\right)$$f(n)$$o\left(f\left(n\right)\right)$$o(f(n))$$g\left(n\right)$$g(n)$$g\left(n\right)=o\left(f\left(n\right)\right)$$g(n) = o(f(n))$ .

Se tudo que você sabe é que um algoritmo é executado no tempo , não está claro se um algoritmo que é executado no tempo é uma melhoria, qualquer que seja são. Isso ocorre porque O grande é apenas um limite superior no tempo de execução. Em vez disso, é comum considerar a pior complexidade do tempo e estimar como um grande, e não como um grande .$O\left(f\left(n\right)\right)$$O(f(n))$$O\left(g\left(n\right)\right)$$O(g(n))$$f\left(n\right),g\left(n\right)$$f(n),g(n)$$\mathrm{\Theta }$$\Theta$$O$$O$

21
Talvez seja melhor tomar no seu primeiro parágrafo. Usar uma função decrescente parece um pouco enganador. $g\left(n\right)=1$$g(n)=1$
David Richerby

1
@DavidRicherby: Talvez um pouco, mas o OP nunca disse que eles tinham um algoritmo rodando em então a monotonicidade não pode ser assumida. $O\left(g\left(n\right)\right)$$O(g(n))$
Kevin

7
@Kevin Sure but the context is computer science and, in computer science, big-O notation is usually used for nondecreasing functions. Probably the asker was thinking in those terms.
David Richerby

11

Remember that $O\left(...\right)$$O(...)$ notation is meant for analyzing how the task grows for different sizes of input, and specifically leaves out multiplicative factors, lower-order term, and constants.

Suponha que você tenha um algoritmo cujo tempo de execução real seja (supondo que você possa realmente contar as instruções e saber os horários exatos e assim por diante, o que é reconhecidamente uma enorme suposição nos sistemas modernos). Suponha que você crie um novo algoritmo que seja , mas o tempo de execução real é . Suponha também que você saiba que o software para usar esse algoritmo nunca verá um tamanho de problema de .$O\left({n}^{2}\right)$$O(n^2)$$1{n}^{2}+2n+1$$1n^2+2n+1$$O\left(n\right)$$O(n)$$1000n+5000$$1000n + 5000$$n>10$$n>10$

So, which would you chose - the $O\left(n\right)$$O(n)$ algorithm that's going to take 15000 units of time, or the $O\left({n}^{2}\right)$$O(n^2)$ one that's only going to take 121 units? Now if your software evolves to handling problem sizes of $n>100000$$n>100000$, which one would you pick? What would you do if your problem size varies greatly?

2
"never see a problem size of n>10" - then we'd not use the O notation at all, would we...
AnoE

5
@AnoE Simple numbers for the sake of argument. The same logic applies whether you're analyzing for a problem size of 10 vs 1e5 or analyzing for 1e6 vs 1e9.
twalberg

1
@AnoE Most computer programs do not try to handle an infinitely growing problem size. So there will be a trade-off. That's why big-O is for theoretical computer science, and the concepts can be applied to improve actual programs.
mbomb007

Exactly, @mbomb007. The question title is "What does a faster algorithm mean in theoretical computer science?" and he has this in the body: "Does it make sense, in the context of theoretical computer science...".
AnoE

@AnoE From experience, O notation is used when n<10 all the time! Not that it's a good idea... but it's totally something that's done!
Cort Ammon - Reinstate Monica

5

$g\left(n\right)\in o\left(f\left(n\right)\right)$$g(n) \in o\bigl(f\left(n\right)\bigr)$$g$$g$$f$$f$ the time complexity of the old.

$\mathrm{\Theta }\left({n}^{2}\right)$$\Theta(n^2)$$\mathrm{\Theta }\left(n\mathrm{log}n\right)$$\Theta(n \log n)$ time, but it’s widely-used in practice because of its good average-case running time. It can additionally be tweaked to run very quickly in the cases that are most frequent in the wild, such as arrays that are mostly in the right order.

And sometimes, even theoretical computer scientists use “faster” the same way normal people do. For example, most implementations of String classes have Short String Optimization (also called Small String Optimization), even though it only speeds things up for short strings and is pure overhead for longer ones. As the input size gets larger and larger, the running time of a String operation with SSO is going to be higher by a small constant term, so by the definition I gave in the first paragraph, removing SSO from a String class makes it “faster.” In practice, though, most strings are small, so SSO makes most programs that use them faster, and most computer-science professors know better than to go around demanding that people only talk about orders of asymptotic time complexity.

1

There is not one unified definition of what a "faster algorithm" is. There is not a governing body which decides whether an algorithm is faster than another.

To point out why this is, I'd like to offer up two different scenarios which demonstrate this murky concept.

The first example is an algorithm which searches a linked list of unordered data. If I can do the same operation with an array, I have no change on the big Oh measure of performance. Both searches are O(n). If I just look at the big Oh values, I might say that I made no improvement at all. However, it is known that array lookups are faster than walking a linked list in the majority of cases, so one may decide that that made an algorithm "faster," even though the big Oh did not change.

If I may use the traditional example of programming a robot to make a PBJ sandwich, I can show what I mean another way. Consider just the point where one is opening the jar of peanut butter.

Pick up the jar
Grab the lid
Unscrew the lid


Versus

Pick up the jar
Put the jar back down
Pick up the jar
Put the jar back down
Pick up the jar
Put the jar back down
Pick up the jar
Put the jar back down
Pick up the jar
Put the jar back down
Pick up the jar
Grab the lid
Unscrew the lid


Even in the most academic theoretical setting I can think of, you'll find that people accept that the first algorithm is faster than the second, even though the big Oh notation results are the same.

By contrast, we can consider an algorithm to break RSA encryption. At the moment, it is perceived that this process is probably O(2^n), where n is the number of bits. Consider a new algorithm which runs n^100 faster This means my new process runs in O(2^n/n^100). However, in the world of cryptography, a polynomial speedup to an exponential algorithm is traditionally not thought of as a theoretical speed up at all. When doing security proofs, it's assumed that an attacker may discover one of these speed ups, and that it will have no effect.

So in one circumstance, we can change a O(n) to O(n), and call it faster. In a different circumstance, we can change a O(2^n) to O(2^n/n^100), and claim there was no meaningful speed up at all. This is why I say there is no one unified definition for a "faster algorithm." It is always contextually dependent.

1

I can't comment yet, but I feel like the current answers, while correct and informative, do not address part of this question. First, let us write an expression equivalent to $A\left(n\right)\in O\left(f\left(n\right)\right)$$A(n) \in O(f(n))$.

Now, let us assume we are talking about an arbitrarily increasing function $g\left(n\right)$$g(n)$ where $\underset{n\to \mathrm{\infty }}{lim sup}g\left(n\right)=\mathrm{\infty }$$\limsup_{n\to\infty} g(n) = \infty$ and let us create the function $h\left(n\right)=\frac{f\left(n\right)}{g\left(n\right)}$$h(n) = \frac{f(n)}{g(n)}$.

We are given that the run-time of the "improved" algorithm ${A}^{\prime }\left(n\right)$$A'(n)$ is in $O\left(h\left(n\right)\right)$$O(h(n))$. Suppose that the run-time of the original algorithm $A\left(n\right)$$A(n)$ is also in $O\left(h\left(n\right)\right)$$O(h(n))$. This can be written as follows.

Using the rules of limits, we can also write:

${c}_{h}=\underset{n\to \mathrm{\infty }}{lim sup}\frac{A\left(n\right)}{h\left(n\right)}=\underset{n\to \mathrm{\infty }}{lim sup}\frac{A\left(n\right)g\left(n\right)}{f\left(n\right)}={c}_{f}\cdot \underset{n\to \mathrm{\infty }}{lim sup}g\left(n\right)$

Since ${c}_{h}<\mathrm{\infty }$$c_h \lt \infty$, this can only be true if ${c}_{f}=0$$c_f = 0$.

The contrapositive statement is: If ${c}_{f}\ne 0$$c_f \neq 0$, then $A\left(n\right)\notin O\left(h\left(n\right)\right)$$A(n) \notin O(h(n))$.

In words, ${A}^{\prime }\left(n\right)$$A'(n)$ is an "improvement" on $A\left(n\right)$$A(n)$ under the additional conditions that $A\left(n\right)\in \mathrm{\Theta }\left(f\left(n\right)\right)$$A(n) \in \Theta(f(n))$ and $g\left(n\right)$$g(n)$ is arbitrarily increasing.

Additionally, this should show why the statement that $A\left(n\right)\in O\left(f\left(n\right)\right)$$A(n) \in O(f(n))$ is not strong enough to draw a conclusion about whether ${A}^{\prime }\left(n\right)$$A'(n)$ is an "improvement." In short, $A\left(n\right)$$A(n)$ could already be in $O\left(h\left(n\right)\right)$$O(h(n))$.

1
Your limit should be limit superior.
Yuval Filmus

1
@YuvalFilmus Updated
Jared Goguen
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.