Algoritmo fattoriale più efficiente della moltiplicazione ingenua

So codificare per fattoriali usando sia iterativi che ricorsivi (ad n * factorial(n-1)es. Per es.). Ho letto in un libro di testo (senza ulteriori spiegazioni) che esiste un modo ancora più efficiente di codificare i fattoriali dividendoli a metà in modo ricorsivo.

Capisco perché potrebbe essere così. Tuttavia, volevo provare a codificarlo da solo, e non credo di sapere da dove iniziare. Un amico mi ha suggerito di scrivere prima i casi base. e stavo pensando di usare array in modo da poter tenere traccia dei numeri ... ma non riesco davvero a trovare una via d'uscita per progettare un tale codice.

Che tipo di tecniche dovrei ricercare?

L'algoritmo migliore che si conosca è quello di esprimere il fattoriale come prodotto dei poteri principali. È possibile determinare rapidamente i numeri primi e la giusta potenza per ciascun numero primo usando un approccio a setaccio. Il calcolo di ogni potenza può essere eseguito in modo efficiente utilizzando la quadratura ripetuta, quindi i fattori vengono moltiplicati insieme. Questo è stato descritto da Peter B. Borwein, On the Complexity of Calculating Factorials , Journal of Algorithms 6 376–380, 1985. ( PDF ) In breve, $n!$può essere calcolato in $O(n(\log n)^3\log \log n)$ tempo, rispetto al tempo richiesto quando si utilizza la definizione.$\Omega(n^2 \log n)$

Ciò che il libro di testo forse significava era il metodo di divisione e conquista. Si possono ridurre le moltiplicazioni usando il modello regolare del prodotto.$n-1$

Let denotare 1 ⋅ 3 ⋅ 5 ⋯ ( 2 n - 1 ) come notazione conveniente. Riorganizza i fattori di ( 2 n ) ! = 1 ⋅ 2 ⋅ 3 ⋯ ( 2 n ) come ( 2 n ) ! = n ! ⋅ 2 n ⋅ 3 ⋅ 5 ⋅ 7 ⋯ ( 2 n $n?$$1 \cdot 3 \cdot 5 \dotsm (2n-1)$$(2n)! = 1 \cdot 2 \cdot 3 \dotsm (2n)$ Supponiamo ora n = 2 k per un numero intero k > 0 . (Questo è un presupposto utile per evitare complicazioni nella discussione che segue, e l'idea può essere estesa al n generale.) Quindi ( 2 k ) ! = ( 2 k - 1 ) ! 2 2 k - 1 ( 2 k - 1 ) ? e espandendo questa ricorrenza, ( 2 k ) !

$$(2n)! = n! \cdot 2^n \cdot 3 \cdot 5 \cdot 7 \dotsm (2n-1).$$ $n = 2^k$$k>0$$n$$(2^k)! = (2^{k-1})!2^{2^{k-1}}(2^{k-1})?$ Informatica( 2 k - 1 ) $$(2^k)! = \left(2^{2^{k-1}+2^{k-2}+\dots+2^0}\right) \prod_{i=0}^{k-1} (2^i)? = \left(2^{2^k - 1}\right) \prod_{i=1}^{k-1} (2^i)?.$$ $(2^{k-1})?$e moltiplicare i prodotti parziali in ciascuna fase richiede moltiplicazioni. Questo è un miglioramento di un fattore di quasi 2 da 2 k - 2 moltiplicazioni usando solo la definizione. Sono necessarie alcune operazioni aggiuntive per calcolare la potenza di 2 , ma nell'aritmetica binaria ciò può essere fatto in modo economico (a seconda di ciò che è esattamente richiesto, potrebbe essere necessario aggiungere un suffisso di 2 k - 1 zero).$(k-2) + 2^{k-1} - 2$$2$$2^k-2$$2$$2^k-1$

Il seguente codice Ruby implementa una versione semplificata di questo. Questo non evita di ricalcolare anche dove potrebbe farlo:$n?$

def oddprod(l,h)
  p = 1
  ml = (l%2>0) ? l : (l+1)
  mh = (h%2>0) ? h : (h-1)
  while ml <= mh do
    p = p * ml
    ml = ml + 2
  end
  p
end

def fact(k)
  f = 1
  for i in 1..k-1
    f *= oddprod(3, 2 ** (i + 1) - 1)
  end
  2 ** (2 ** k - 1) * f
end

print fact(15)

Anche questo codice di primo passaggio migliora il banale

f = 1; (1..32768).map{ |i| f *= i }; print f

di circa il 20% nei miei test.

Con un po 'di lavoro, questo può essere ulteriormente migliorato, eliminando anche la necessità che sia una potenza di 2 (vedere la discussione approfondita ).$n$$2$

Tieni presente che la funzione fattoriale cresce così velocemente che avrai bisogno di numeri interi di dimensioni arbitrarie per ottenere qualsiasi beneficio da tecniche più efficienti rispetto all'approccio ingenuo. Il fattoriale di 21 è già troppo grande per adattarsi a un 64-bit unsigned long long int.

$n!$$n$

$\Theta(|a| \cdot |b|)$$|x|$$x$$\Omega(|a| + |b|)$$\max(|a|,|b|)$

Con questo sfondo, l' articolo di Wikipedia dovrebbe avere un senso.

Poiché la complessità delle moltiplicazioni dipende dalla dimensione degli interi che si stanno moltiplicando, è possibile risparmiare tempo organizzando le moltiplicazioni in un ordine che mantiene i numeri moltiplicati piccoli. Funziona meglio se organizzi che i numeri abbiano approssimativamente le stesse dimensioni. La "divisione a metà" a cui fa riferimento il tuo libro di testo consiste nel seguente approccio di divisione e conquista per moltiplicare un (multi) insieme di numeri interi:

1. $1$$n$$|a \cdot b| \approx |a| + |b|$
2. Applicare l'algoritmo in modo ricorsivo su ciascuno dei due sottoinsiemi.
3. Moltiplica i due risultati intermedi.

Vedi il manuale GMP per maggiori dettagli.

$1$$n$

_$n!$

$n!$$n$$171!$$n!$$171$

$\log(n!)$$\Gamma$$\log \Gamma$$n!$

A parte questo, i tuoi algoritmi iterativi e ricorsivi sono equivalenti (fino a errori in virgola mobile), poiché stai usando la ricorsione della coda.