Qual é o tempo de execução desse algoritmo recursivo?

Fiz o seguinte programa Haskell (não-destruído) para o desafio do código-golfe de calcular o primeiro $n$ valores de A229037 .

Esta é a minha solução proposta para calcular o º valor: $n$

a n | n<1        = 0 
    | n<3        = 1
    | otherwise  = head (goods n)

goods n = [x | x <- [1..], isGood x n]

isGood x n = and [ x - a(n-k) /= a(n-k) - a(n-k-k) || a(n-k-k) == 0 | k <- [1..n] ]

Observe que o Haskell não armazena em cache ou memoriza esses valores automaticamente.

A página OEIS para a sequência fornece o fato de que , portanto, pode ser substituído por , pois o algoritmo nunca alcançará um maior que . $a(n) \leq (n+1)/2$ [1..][1..(n+1)/2] $x$ $\frac{n+1}{2}$

Tentando contar chamadas de função, deduzi o seguinte limite superior , o número de chamadas de função que o algoritmo leva para uma entrada : $T(n)$ $n$

\begin{aligned} T (n) & = \sum_{x = 1}^{(n + 1) / 2} \sum_{k = 1}^{n} 2 T (n - k) + 2 T (n - 2 k) \\ \leq \sum_{x = 1}^{(n + 1) / 2} \sum_{k = 1}^{n} T (n - k) \\ \leq \sum_{x = 1}^{(n + 1) / 2} \sum_{k = 1}^{n} 4 T (n - 1) \\ \leq \sum_{x = 1}^{(n + 1) / 2} 4 n T (n - 1) \\ \leq 4 n T (n - 1) \frac{n + 1}{2} \\ \leq 2 n (n + 1) T (n - 1)) \end{aligned}

$\begin{align} T(n) &= \sum_{x=1}^{(n+1)/{2}} \sum_{k=1}^{n} 2~T(n-k) + 2~T(n-2 k) \\ &\leq \sum_{x=1}^{(n+1)/{2}} \sum_{k=1}^{n} ~T(n-k)\\ &\leq \sum_{x=1}^{(n+1)/{2}} \sum_{k=1}^{n} 4~T(n-1)\\ &\leq \sum_{x=1}^{(n+1)/{2}} 4~n~T(n-1)\\ &\leq 4~n~T(n-1)~\frac{n+1}{2}\\ &\leq 2~n~(n+1)~T(n-1) ) \end{align}$

Liguei a fórmula final no Mathematica:

RSolve[{T[n] == 2*T[n - 1]*n*(n + 1), T[1] == 1}, T[n], n]

E consegui, depois de um pouco de simplificação: $T(n) \leq ~2^n~n!~(n + 1)!$

A proporção média entre este e o tempo de execução do programa Haskell, para é de e o desvio padrão das proporções é de cerca de . (Curiosamente, o gráfico de log dos índices parece ser uma linha reta). $n \in [12,20]$ $2.0 \cdot 10^{39}$ $6.0 \cdot 10^{39}$

As relações com a primeira linha, definindo , têm uma média e desvio padrão de e , respectivamente, mas seu gráfico salta bastante. $T(n)$ $4.8 \cdot 10^6$ $1.8 \cdot 10^6$

Como posso obter uma ligação melhor à complexidade do tempo desse algoritmo?

Aqui está o algoritmo em C válido (menos as declarações avançadas), que eu acredito que é aproximadamente equivalente ao código Haskell:

int a(int n){
    if (n < 1) {
        return 0;
    } else if (n < 3) {
        return 1;
    } else {
        return lowestValid(n);
    }
}

int lowestValid(int n){
    int possible = 1; // Without checking, we know that this will not exceed (n+1)/2

    while (notGood(possible, n)) {
        possible++;
    }
    return possible;
}

int notGood(int possible, int n){
    int k = 1;

    while (k <= n) {
        if ( ((possible - a(n-k)) == (a(n-k) - a(n-2*k))) && (a(n-2*k) != 0) ) {
            return 1;
        } else {
            k++;
        }
    }
    return 0;
}

A versão C leva cerca de 5 minutos para calcular e a versão Haskell leva aproximadamente o mesmo para . $a(17)$ $a(19)$

As primeiras vezes das versões:

Haskell: [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0e-2,3.0e-2,9.0e-2,0.34,1.42,11.77,71.68,184.37,1815.91]
C:       [2.0e-6, 1.0e-6, 1.0e-6, 2.0e-6, 1.0e-6, 6.0e-6, 0.00003,0.00027, 0.002209, 0.005127, 0.016665, 0.080549, 0.243611, 0.821537, 4.56265, 24.2044, 272.212]

— Michael Klein
fonte

Alterei tags e título para deixar claro que se trata de uma análise de algoritmo, não de uma questão de teoria da complexidade. "Supondo que multiplicação e adição são insignificantes" - você pode ? Sério ? Ainda é melhor dizer o que você está contando, porque é provável que você não esteja contando a maioria das coisas. Veja também nossa pergunta de referência .

— Raphael

Você já tentou plotar seu resultado (com algum fator constante) em relação aos tempos de execução das medidas reais? (Geralmente, é mais informativo plotar a razão e adivinhar se ela converge para algo em .) Dito isso, acho difícil ajudar aqui, pois a ansatz para depende dos detalhes de Haskell, que nem todos aqui falam. . Especificamente, como é avaliada essa compreensão do conjunto? Está sendo memorizado? Você pode obter respostas melhores (ou qualquer, realmente!), Se você incluiu uma versão em pseudo-código que expõe tanto do que realmente acontece quanto necessário para uma análise rigorosa.

O (1)

$O(1)$

T

$T$ a

— Raphael

Finalmente, o uso de métodos adequados para derivar limites do Landau provavelmente é inútil. Qualquer função desse tipo pode caber apenas em um conjunto fixo de funções; Eu acho que o Mathematica usou os piores modelos exponenciais lá, e assim fez um mau trabalho ao capturar um crescimento superexponencial.

— Raphael

@Raphael Seus comentários foram muito úteis. Vou investigar mais quando tiver algum tempo. Além disso, o veio do ajuste dos logaritmos dos valores a uma linha, que era mais um tiro no escuro do que qualquer outra coisa.

O (n^{2} 2)

$O(n^22)$

— Michael Klein

Você pode escrever sua recorrência como

T (n) = (n + 1) (T (n - 1) + 2 T (n - 2) + T (n - 3) + 2 T (n - 4) + \dots) .

$T(n) = (n+1)(T(n-1) + 2T(n-2) + T(n-3) + 2T(n-4) + \cdots).$ Em particular,

T (n) \geq (n + 1) T (n - 1)

$T(n) \geq (n+1) T(n-1)$ . Isso significa que a sequência

T (n)

$T(n)$ cresce muito rapidamente, e em particular

T (n - 1) + 2 T (n - 2) + \dots \leq T (n - 1) [1 + \frac{2}{n} + \frac{1}{n (n - 1)} + \frac{2}{n (n - 1) (n - 2)} + \dots] = (1 + O (1 / n)) T (n - 1) .

$T(n-1) + 2T(n-2) + \cdots \leq T(n-1) \left[ 1 + \frac{2}{n} + \frac{1}{n(n-1)} + \frac{2}{n(n-1)(n-2)} + \cdots \right] = (1+O(1/n)) T(n-1).$ Portanto

T (n) \leq (n + O (1)) T (n - 1) .

$T(n) \leq (n+O(1)) T(n-1).$ Isso significa que

T (n) = O ((n + O (1))!),

$T(n) = O((n+O(1))!),$ e entao

T (n) = O (n^{O (1)} (n / e)^{n}) .

$T(n) = O\left(n^{O(1)} (n/e)^n\right).$ Isso melhora o seu limite por uma raiz quadrada.

— Yuval Filmus
fonte