Numero di multiset in modo tale che ciascun numero sia compreso tra 1 e

Il mio problema. Dato , voglio contare il numero di multinsiemi valida . Una multiset $n$ $S$ $S$ è valida se

La somma degli elementi di è $S$ , e $n$
Ogni numero da a può essere espresso in modo univoco come somma di alcuni degli elementi di $1$ $n$ $S$ .

Esempio. Ad esempio, se allora sono validi . $n=5$ $\{1,1,1,1,1\}, \{1,2,2\}, \{1,1,3\}$

Tuttavia, non è valido perché 2 può essere formato da e (ovvero, 2 può essere espresso come e ) , quindi la seconda condizione non regge. Allo stesso modo 3 può essere formato da e . $S=\{1,1,1,2\}$ $\{1,1\}$ $\{2\}$ $2=1+1$ $2=2$ $\{2,1\}$ $\{1,1,1\}$

} non è valido perché tutti i numeri da a possono essere creati in modo univoco, ma la somma degli elementi di non è $S=\{1,2,4$ $1$ $5$ $S$ $5$ .

Ho provato a trovare un buon algoritmo per questo problema per un po 'di tempo ma non riesco a risolverlo. Viene da codechef . Ho visto alcune delle soluzioni presentate ma non riuscivo ancora a ottenere la logica per risolvere il problema. NOTA: il limite di tempo per la domanda è di 10 secondi e $n<10^9$

Per un multiset userò la notazione se , il che significa verifica $S = \{(a_1, c_1), (a_2, c_2) ... \}$ $a_i<a_j$ $i<j$ $a_i$ $c_i$ tempi in multinsieme S.

Fino ad ora ho tratto alcune conclusioni

Il primo elemento del multiset ordinato richiesto dovrebbe essere $1$
Sia essere un insieme seguendo le due proprietà quindi $S=\{1,a_2 \cdots a_k\} | a_1 \leq a_2\cdots \leq a_k$ $\forall r<k \ \ a_{r+1} = a_r \text{ or } (\sum_{i=0}^ra_i) + 1$
Sia , dove sta verificando tempi, segue le proprietà richieste quindi dalla conclusione sopra possiamo dire che e $S=\{(1,c_1),(a_2,c_2) \cdots (a_k,c_k)\} | a_1 \leq a_2\cdots \leq a_k$ $a_i$ $c_i$ $\forall i \ a_i|n+1$ se . Prova: $a_i | a_j$ $j > i$
$a_{i+1} = (a_ic_i + a_i -1 ) + 1 \Rightarrow a_i | a_{i+1}$
Ora considera cioè tutti i i numeri successivi dopo 1 saranno un multiplo di . Quindi lascia che $S=\{ \underbrace{1,1 \cdots 1}_{d-1},d,d \cdots d,dm_1, dm_1 \cdots dm_1,dm_2, dm_2 \cdots dm_2, \cdots \}$ $d$ $f(n)$ essere il conteggio di tale multiset possibile quindi dove sto sommando tutto il numero possibile di(). In altri termini $f(n) = \sum_{d|n+1, d\neq 1} f(\frac{n-(d-1)}{d})$ $1's$ $=d-1$ $f(n-1)=g(n)=\sum_{d|n,d \neq n}g(d)$

Alla fine il mio problema si riduce a questo: trova in modo efficiente in modo che non superi il limite di tempo. $g(n)$

algorithms integers

— Lega della Giustizia
fonte

Hai verificato se è opportuno chiedere ad altre persone di pubblicare pubblicamente soluzioni e algoritmi per problemi di pratica? Le FAQ di Codechef sembrano aspettarsi che le soluzioni non vengano pubblicate pubblicamente (ad eccezione di alcuni problemi di base). Pubblicare una soluzione qui "rovinerebbe" i problemi di pratica per gli altri, o è considerato OK? Non ho familiarità con le norme e l'etichetta della comunità Codechef.

— DW

Non ho trovato nulla correlato a non pubblicare domande di dominio pubblico nelle faq e questa limitazione riguarda i problemi di contestazione in corso e non quelli di pratica.

— Justice League,

@DW Non credo che a loro dispiacerebbe se discutiamo di problemi che non provengono da concorsi in corso.

— Ravi Upadhyay,

Stai cercando il numero di partizioni del numero di input. Ti suggerisco di fare qualche ricerca usando questa parola d'ordine.

— Raffaello

@Raphael, sono d'accordo, il poster dovrebbe leggere queste tecniche. Non è esattamente lo stesso problema - la prima condizione del poster richiede che si tratti di una partizione, ma la seconda condizione impone ulteriori restrizioni (per la modifica univoca ) - ma potrebbe essere possibile applicare le stesse tecniche utilizzate per contare il numero delle partizioni, con alcune modifiche per far fronte al requisito aggiuntivo.

— DW

Risposte:

Ecco cosa sta facendo la soluzione più veloce . Sta effettivamente calcolando la tua funzione Dato , lo fattorizziamo (vedi sotto) e quindi calcoliamo tutti i fattori (vedi sotto) in un ordine tale che implica (proprietà P). Ora calcoliamo secondo la formula andando oltre i fattori nell'ordine dato. La proprietà P assicura che quando calcoliamo , abbiamo già calcolato per tutti i fattori non banali

g (n) = \sum_{\begin{matrix} d ∣ n \\ d < n \end{matrix}} g (d), g (1) = 1.

$g(n) = \sum_{\substack{d \mid n \\ d < n}} g(d), \quad g(1) = 1.$

n

$n$

f_{1}, \dots, f_{m}

$f_1,\ldots,f_m$

f_{i} | f_{j}

$f_i|f_j$

i \leq j

$i \leq j$

g

$g$

g (d)

$g(d)$

g (e)

$g(e)$

e

$e$ di

d

$d$ . C'è anche un'ottimizzazione (vedi sotto).

Più in dettaglio, esaminiamo i fattori in ordine e, per ogni fattore , troviamo tutti i suoi fattori non banali controllando quale di divide . $f_i$ $f_1,\ldots,f_{i-1}$ $f_i$

Factoring: preelaborazione: facciamo un elenco di tutti i numeri primi inferiori a usando il setaccio Eratosthenes. Dato , usiamo semplicemente la divisione di prova. $10^9$ $n$

Generazione di tutti i fattori: questo viene fatto in modo ricorsivo. Supponiamo che . Si corre nested loop , e l'uscita . Puoi provare la proprietà P per induzione. $n = p_1^{k_1} \cdots p_t^{k_t}$ $t$ $l_1 \in \{0,\ldots,k_1\},\ldots,l_t \in \{0,\ldots,k_t\}$ $p_1^{l_1}\cdots p_t^{l_t}$

Ottimizzazione: poiché il programma è eseguito su più input, possiamo usare la memoization per risparmiare tempo su diversi input. Memorizziamo solo piccoli valori (fino a $10^5$ ) e questo ci consente di memorizzare tutti i valori memorizzati in un array. L'array è inizializzato con zero e quindi possiamo dire quali valori sono già noti (poiché tutti i valori calcolati sono positivi).

Se la scomposizione in fattori primi di è , allora dipende solo da , e di fatto solo dalla versione ordinata di questo vettore . Ogni numero inferiore a ha al massimo fattori primi (con ripetizione) e poiché , sembra possibile calcolare $n+1$ $p_1^{k_1},\ldots,p_t^{k_t}$ $f(n)$ $(k_1,\ldots,k_t)$ $10^9$ $29$ $p(29)=4565$ $f$ (o meglio ) per tutti, ricorsivamente. Questa soluzione potrebbe essere più veloce se ci fossero molti input diversi; così com'è, ci sono al massimo . $g$ $10$

È anche possibile che questa funzione, mappando le partizioni sulla corrispondente , abbia una forma analitica esplicita. Ad esempio, , è dato da A000670 e è dato da A005649 o A172109 . $g$ $g(p^k) = 2^{k-1}$ $g(p_1\ldots p_t)$ $g(p_1^2 p_2\ldots p_t)$

— Yuval Filmus
fonte

OK, quindi hai una relazione di ricorrenza per (vedi la fine della tua domanda). $g(\cdot)$

A questo punto sembra che un approccio naturale sarebbe scrivere l'algoritmo ricorsivo per calcolare e applicare la memoizzazione in modo da non calcolare più di una volta. In altre parole, quando si calcola , lo si memorizza in una tabella hash che mappa ; se hai bisogno di conoscere di nuovo in futuro, puoi cercarlo nella tabella hash. $g(n)$ $g(i)$ $g(i)$ $i \mapsto g(i)$ $g(i)$

$n$ $n$ $n\le 10^9$

$g(1),g(2),g(3),g(4),g(5),\ldots$

— DW
fonte

Ecco un suggerimento per iniziare. Applicare algoritmi di programmazione dinamica standard per enumerare il set di partizioni di un numero intero e aggiungere un po 'di logica per verificare quale di queste consente la modifica univoca controllando iterativamente tutte le somme, apportando modifiche e verificando l'univocità.

$S$ $i$ $1 \le i \le n$ $S$ $i$

$S$ $n$ $S$

$P(n)$ $P(1), P(2), \dots, P(n)$ $P(n+1)$

Ecco un approccio che probabilmente sarà migliore.

$S$ $n$ $T$ $S$ $T$ $n'$

$x$ $S$ $S$ $T$ $x$ $S$ $S$ $T$ $n$

$S$ $A[1\ldots |S|,1 \ldots n]$ $A[i,j]$ $j$ $i$ $S$ $i$ $S$ $S$ $S=\{s_1,s_2,\dots,s_k\}$ $s_1\le s_2 \le \cdots \le s_k$ $A[i,j]$ $A[1\ldots i-1, 1\ldots j-1]$ $A[i,j] = A[i-1,j] \lor A[i-1,j-s_i]$ $j>s_i$ $A[i,j]=A[i-1,j]$ $S$

$T$ $S$ $S$ $T$ $n$ $S$ $n'$ $T$ $n+1,n+2,\ldots,n'$ $T$ $A$ $A[1\ldots |T|, 1 \ldots n']$ $A[|T|,n+1], A[|T|,n+2], \ldots, A[|T|,n']$ $T$ $S$

$S$ $n$ $n\le 20$ $P[1\ldots 20]$ $P[5]$ $S$ $P[n]$ $S$ $n$

$P[n]$ $P[1]$ $\{1\}$ $n$ $S \in P[n]$ $T$ $S$ $n'$ $T$ $T$ $P[n']$ $n' \le 20$

Questo dovrebbe essere abbastanza fattibile. In bocca al lupo! Divertiti! Lavorare attraverso i dettagli sarà un buon esercizio di apprendimento nella programmazione dinamica.

— DW
fonte

n

$n$