Quel est le temps d'exécution de cet algorithme récursif?

J'ai fait le programme Haskell (non golfé) suivant pour le défi de golf de code de calculer les premières valeurs de A229037 . $n$

Voici ma solution proposée pour calculer la ème valeur: $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] ]

Notez que Haskell ne met pas en cache ni ne mémorise automatiquement ces valeurs.

La page OEIS pour la séquence donne le fait que , donc le pourrait être remplacé par , car l'algorithme n'atteindra jamais un supérieur à . $a(n) \leq (n+1)/2$ [1..][1..(n+1)/2] $x$ $\frac{n+1}{2}$

En essayant de compter les appels de fonction, j'ai dérivé la limite supérieure , le nombre d'appels de fonction que l'algorithme prend pour une entrée : $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}$

J'ai branché la formule finale dans Mathematica:

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

Et obtenu, après une petite simplification: $T(n) \leq ~2^n~n!~(n + 1)!$

Le rapport moyen entre cela et le temps d'exécution du programme Haskell, pour est de et l'écart-type des ratios est d'environ . (Curieusement, le diagramme logarithmique des ratios semble être une ligne droite). $n \in [12,20]$ $2.0 \cdot 10^{39}$ $6.0 \cdot 10^{39}$

Les rapports avec la première ligne, définissant , ont une moyenne et un écart type de et , respectivement, mais son tracé saute beaucoup. $T(n)$ $4.8 \cdot 10^6$ $1.8 \cdot 10^6$

Comment puis-je obtenir une meilleure limite sur la complexité temporelle de cet algorithme?

Voici l'algorithme en C valide (moins les déclarations avancées), qui je crois est à peu près équivalent au code 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;
}

La version C prend environ 5 minutes pour calculer et la version Haskell prend environ la même chose pour . $a(17)$ $a(19)$

Les premières fois des versions:

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
source

J'ai changé les balises et le titre pour préciser qu'il s'agit d'une analyse d'algorithme, pas d'une question de théorie de la complexité. "En supposant que la multiplication et l'addition sont négligeables" - pouvez-vous ? Vraiment ? Il vaut toujours mieux dire ce que vous comptez, car il est probable que vous ne comptez pas la plupart des choses. Voir aussi notre question de référence .

— Raphael

Avez-vous essayé de tracer votre résultat (avec un facteur constant) par rapport aux durées de mesure réelles? (Il est souvent plus instructif de tracer le rapport et de deviner s'il converge vers quelque chose dans

O (1)

$O(1)$ .) Cela dit, j'ai du mal à aider ici depuis l'ansatz de

T

$T$ dépend des détails de Haskell, dont tout le monde ici ne parle pas. Plus précisément, comment cette compréhension d'ensemble est-elle évaluée? Est amémorisé? Vous pouvez obtenir de meilleures réponses (ou n'importe laquelle, vraiment!) Si vous incluez une version de pseudo-code qui expose autant de ce qui se passe réellement que nécessaire pour une analyse rigoureuse.

— Raphael

Enfin, l'utilisation de méthodes d'ajustement pour dériver des bornes de Landau est probablement futile. Une telle fonction ne peut tenir que contre un ensemble fixe de fonctions; Je suppose que Mathematica a utilisé les pires modèles exponentiels là-bas, donc a fait un mauvais travail en capturant une croissance super-exponentielle.

— Raphael

@Raphael Vos commentaires ont été très utiles. J'y reviendrai plus quand j'aurai du temps. Également

O (n^{2} 2)

$O(n^22)$ est venu d'ajuster les logarithmes des valeurs à une ligne, qui était plus un coup dans l'obscurité qu'autre chose.

— Michael Klein

Vous pouvez écrire votre récurrence comme

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).$ En particulier,

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

$T(n) \geq (n+1) T(n-1)$ . Cela signifie que la séquence

T (n)

$T(n)$ croît très rapidement, et en particulier

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).$ Donc

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

$T(n) \leq (n+O(1)) T(n-1).$ Cela signifie que

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

$T(n) = O((n+O(1))!),$ et donc

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

$T(n) = O\left(n^{O(1)} (n/e)^n\right).$ Cela améliore votre lié par une racine carrée.

— Yuval Filmus
source