Il meno comune non divisore

$S$$d$$S$$\forall x \in S,\ d \nmid x$

Indica $n = |S|$e $C = \max(S)$ . Considera la funzione $F(x) =$ il numero primo minimo che non divide $x$ . È facile vedere che $F(x) \leq \log x$ . E per una serie $S$ , lasciate $F(S) =$ il minimo primo che non divide alcun elemento di $S$ . Abbiamo un limite superiore

Pertanto un semplice algoritmo a forza bruta, che enumera tutti i numeri da $1$ a $n \log C$ e verifica se non divide alcun elemento di $S$ , è polinomiale e ha complessità temporale $O(n^2 \log C)$ .

L'altro modo per risolvere il problema è calcolare tutti i fattori per ogni elemento di $S$ e usarli nell'algoritmo a forza bruta per verificare se $x$ è una risposta nel tempo $O(1)$ . Questo algoritmo ha una complessità temporale $O(n \cdot \min (\sqrt{C}, n \log C) + n \log C)$ e utilizza la memoria $O(n \log C)$ , perché non è necessario calcolare e fattori negozio più grande di $n \log C$ . Per i piccoli $n$ e $C$ funziona meglio.

Nel dettaglio, l'algoritmo è costituito da due parti:

1. Costruisci un set $\hat{S}$ composto da tutti i fattori di tutti gli elementi di $S$ , ovvero

   $$\forall x \in S\ \forall f \le n \cdot \log C, \ (f \mid x \rightarrow f \in \hat{S})$$ Questo può essere fatto nella memoria $O(n \cdot \min (\sqrt{C}, n \log C))$ e $O(n \log C)$ . (Da dove viene? Per qualsiasi elemento di $S$ , possiamo fattorizzarlo utilizzando la fattorizzazione di prova con tutti i numeri fino a $\sqrt{C}$ o tutti i numeri primi fino a $n \log C$ , a seconda di quale sia il più piccolo; quindi ogni elemento di $S$ può essere preso in considerazione nel tempo $O(\min (\sqrt{C}, n \log C))$ .)

2. Trova il numero minimo . Questo passaggio richiede , se si verifica se può essere eseguito in .$d \notin \hat{S}$$O(|\hat{S}|) = O(n \log C)$$x \in \hat{S}$$O(1)$

Ho due domande a cui sono interessato:

1. Esiste un algoritmo più veloce per risolvere il problema?
2. Per dato e , come possiamo costruire un insieme con il massimo divisore minimo comune?$n$$C$$S$

È possibile migliorare il secondo algoritmo utilizzando algoritmi migliori per la fattorizzazione a numeri interi.

Esistono due algoritmi per la fattorizzazione dei numeri interi che sono rilevanti qui:

• GNFS può fattorizzare un numero intero con tempo di esecuzione O ( L C [ 0,33 , 1,92 ] ) .$\le C$$O(L_C[0.33,1.92])$

• L'ECM può trovare un fattore (se presente) con tempo di esecuzione O ( L n log C [ 0,5 , 1,41 ] ) ; trovare tutti i fattori richiederà O ( log C / log ( n log C ) ) il tempo (che è relativamente piccolo rispetto al tempo di esecuzione di ECM).$\le n \log C$$O(L_{n \log C}[0.5,1.41])$$O(\log C / \log(n \log C))$

Qui .$L_n[\alpha,c] = \exp\{c (\log n)^\alpha (\log \log n)^{1-\alpha}\}$

È un'espressione piuttosto orribile per il tempo di esecuzione, ma il fatto importante è che questo è più veloce dei metodi che hai citato. In particolare, è asintoticamente molto più piccola di $L_C[0.33,1.92]$ , cioè GNFS è molto più veloce di provare tutti i possibili fattori≤$\sqrt{C}$ . AncheL n log C [0.5,1.41]è asintoticamente molto più piccolo dinlogC, vale a dire, ECM è molto più veloce che cercare tutti i possibili fattori≤nlogC.$\le \sqrt{C}$$L_{n \log C}[0.5,1.41]$$n \log C$$\le n \log C$

Quindi, il tempo di esecuzione totale per questo metodo è approssimativamente , e questo è asintoticamente migliore del tuo primo metodo e asintoticamente migliore di il tuo secondo metodo. Non so se sia possibile fare ancora meglio.$\tilde{O}(n \min(L_C[0.33,1.92], L_{n \log C}[0.5,1.41]))$

Il non divisore meno comune può essere grande quanto N log C, ma se i numeri N vengono distribuiti casualmente, il non divisore meno comune è probabilmente molto più piccolo, probabilmente molto meno di N. Costruirò tabelle di cui i numeri primi sono divisori di cui numeri.

Per ogni numero primo p abbiamo un indice che significa che tutti i numeri fino a quell'indice sono stati esaminati per divisibilità per p, e abbiamo un elenco di tutti quei numeri che erano divisibili per.$k_p$

Quindi per d = 2, 3, 4, ... proviamo a trovare un numero divisibile per d, o mostriamo che non ce n'è nessuno. Prendiamo il più grande fattore primo p di d. Quindi controlliamo tutti i numeri che erano divisibili per p se sono anche divisibili per d. Se non ne viene trovato nessuno, controlliamo ulteriori numeri con indici> per divisibilità per p, aggiornando k p e l'elenco dei numeri divisibili per p, e verificando se ogni numero è divisibile per d.$k_p$$k_p$

Per verificare se esiste un numero divisibile per p, controlliamo la media dei numeri p. Successivamente, se controlliamo se esiste un numero divisibile per 2p, c'è una probabilità del 50% che dobbiamo controllare solo un numero (quello che è divisibile per p) e una probabilità del 50% per controllare in media 2p più numeri. Trovare un numero divisibile per 3p è molto probabilmente veloce e così via, e non controlliamo mai più di N numeri per divisibilità per p, perché ci sono solo N numeri.

Mi auguro che questo funziona con circa controlli divisibilità.$N^2 / log N$

PS. Quanto sarebbe grande il risultato per i numeri casuali?

Supponiamo che io abbia N numeri casuali. La probabilità che uno dei numeri N sia divisibile per d è 1 - (1 - 1 / d) ^ N. Suppongo che la probabilità che ciascuno dei numeri 1 ≤ d ≤ k sia un fattore di uno dei numeri casuali viene calcolato moltiplicando queste probabilità (Ok, è un po 'complicato, perché queste probabilità probabilmente non sono del tutto indipendenti).

Con questa ipotesi, con N = 1000, c'è una probabilità del 50% che uno dei numeri 1..244 non divida alcun numero e uno su un miliardo che ogni numero fino a 507 divide uno dei numeri. Con N = 10.000 c'è una probabilità del 50% che uno dei numeri 1..1726 non divida alcun numero e uno su un miliardo che ogni numero fino a 2979 divide uno dei numeri.

Suggerirei che per N input casuali, la dimensione del risultato è un po 'più grande di N / ln N; forse qualcosa come N / ln N * (ln ln N) ^ 2. Ecco perché:

La probabilità che almeno uno degli N numeri casuali è divisibile per un d casuale è . Se d è intorno a N, allora 1 - ( 1 - 1 / d ) N è circa 1 - exp (-1) ≈ 0.6321. Questo è per un singolo divisore; è probabile che ciascuno dei diversi numeri d ≈ N sia un divisore di almeno uno dei numeri N che è piuttosto sottile, quindi il massimo d sarà significativamente più piccolo di N.$1 - (1 - 1/d)^N$$1 - (1 - 1/d)^N$

Se d << N, quindi .$1 - (1 - 1/d)^N ≈ 1 - exp (-N / d)$

Se d ≈ N / ln N poi .$1 - exp (-N / d) ≈ 1 - exp (- ln N) = 1 - 1/N$

Aggiungeremo queste probabilità per circa N / ln N valori d, ma per la maggior parte d il risultato sarà significativamente più grande, quindi la più grande d sarà in qualche modo più grande di N / ln N ma significativamente più piccola di N.

PS. Trovare un numero divisibile per d:

Selezioniamo il più grande fattore primo p di d, quindi esaminiamo prima i numeri che erano già noti per essere divisibili per p. Dì d = kp. Quindi in media controlliamo solo k numeri che sono divisibili per p mentre controlliamo questo particolare d, e controlliamo al massimo tutti i valori N per la divisibilità per p complessivo, per tutti i d divisibili per p. In realtà, molto probabilmente controlliamo meno di N valori per la maggior parte dei numeri primi p, perché dopo aver controllato tutti i valori N l'algoritmo probabilmente finisce. Quindi, se il risultato è R, allora mi aspetto che meno di N valori vengano divisi per ciascun numero primo minore di R. Supponendo R ≤ N, si tratta di N ^ 2 / log N checks.

PS. Esecuzione di alcuni test

Ho eseguito questo algoritmo alcune volte con N = 1.000.000 di numeri casuali> 0. Il non divisore meno comune era tra 68.000 e 128.000 con la stragrande maggioranza delle corse tra 100.000 e 120.000. Il numero di divisioni era compreso tra 520 milioni e 1800 milioni, che è molto inferiore a (N / ln N) ^ 2; la maggior parte dei casi utilizzava tra 1000 e 1500 milioni di divisioni.