Somma più grande divisibile per n

Ho fatto questa domanda su StackOverflow , ma penso che qui sia un posto più appropriato.

Questo è un problema dall'introduzione al corso sugli algoritmi :

Hai una matrice $a$ con $n$ numeri interi positivi (la matrice non deve essere ordinata o gli elementi univoci). Suggerisci un algoritmo $O(n)$ per trovare la somma più grande di elementi che è divisibile per $n$ .

Esempio: $a = [6, 1, 13, 4, 9, 8, 25], n = 7$ . La risposta è $56$ (con elementi $6, 13, 4, 8, 25$ )

E 'relativamente facile trovare in utilizzando la programmazione dinamica e memorizzare più grande somma con resto 0 , 1 , 2 , . . . , n - 1 .$O(n^2)$$0, 1, 2,..., n - 1$

Inoltre, se limitiamo l'attenzione a una sequenza contigua di elementi, è facile trovare tale sequenza ottimale in tempo, memorizzando somme parziali modulo n : let S [ i ] = a [ 0 ] + a [ 1 ] + ⋯ + a [ i ] , per ogni resto r ricordare l'indice più grande j tale che S [ j ] ≡ $O(n)$$n$$S[i]=a[0]+a[1]+\dots + a[i]$$r$$j$ , quindi per ogni i consideri S [ j ] - S [ i ] dove j è l'indice corrispondente a r = S [ i ] mod n .$S[j] \equiv r \pmod{n}$$i$$S[j]-S[i]$$j$$r=S[i] \bmod n$

Ma esiste una soluzione -time per il caso generale? Ogni suggerimento sarà apprezzato! Ritengo che questo abbia qualcosa a che fare con l'algebra lineare, ma non sono sicuro di cosa esattamente.$O(n)$

In alternativa, questo può essere fatto in tempo?$O(n \log n)$

Ecco alcune idee casuali:

• L'algoritmo di programmazione dinamica può essere capovolto per cercare una somma più piccola invece di una più grande. Devi solo cercare una somma congruente con il resto della somma dell'intero array, anziché un congruente a zero. Se elaboriamo gli elementi in ordine crescente, questo a volte consente di terminare l'algoritmo dinamico prima di elaborare l'intero array.

  Il costo sarebbe se elaborassimo k elementi. C'è non un limite inferiore di Ω ( n log n ) su questo algoritmo, perché non abbiamo per ordinare tutti gli elementi. Ci vuole solo O ( n log k ) per ottenere i k elementi più piccoli.$O(n k)$$k$$\Omega(n \log n)$$O(n \log k)$$k$

• Se ci preoccupassimo del set con la dimensione maggiore, anziché del set con la somma maggiore, potremmo essere in grado di utilizzare la moltiplicazione polinomiale basata sulla trasformata di Fourier veloce per risolvere il problema in ora. Simile a ciò che viene fatto in 3SUM quando l'intervallo di domini è limitato. (Nota: usa la quadratura ripetuta per fare una ricerca binaria, altrimenti otterrai O ( n k ( log n ) ( log log n ) ) dove $O(n (\log n)^2 (\log \log n))$$O(n k (\log n) (\log \log n))$$k$ è il numero di elementi omessi).

• Quando è composto e quasi tutti i resti sono un multiplo di uno dei fattori n , è possibile risparmiare tempo significativo concentrandosi sui resti che non sono un multiplo di quel fattore.$n$$n$

• Quando un resto rè molto comune o sono presenti solo pochi resti, tenere traccia del 'prossimo slot aperto se si parte da qui e si continua ad avanzare di r' informazioni può salvare un sacco di scansioni per i salti in punti aperti tempo.

• È possibile radere un fattore di registro solo monitorando la raggiungibilità e utilizzando le maschere di bit (nell'algoritmo dinamico capovolto), quindi tornare indietro una volta raggiunto il resto del target.

• L'algoritmo di programmazione dinamica è molto suscettibile di essere eseguito in parallelo. Con un processore per ogni slot di buffer è possibile scendere a . In alternativa, usando O ( n 2 ) di larghezza, e dividere e conquistare l'aggregazione invece dell'aggregazione iterativa, il costo della profondità del circuito può arrivare fino a O ( log 2 n ) .$O(n)$$O(n^2)$$O(\log^2 n)$

• (Meta) Sospetto fortemente che il problema che ti è stato dato riguardi somme contigue . Se si è collegati al problema reale, sarebbe facile verificarlo. Altrimenti sono molto sorpreso da quanto sia difficile questo problema, dato che è stato assegnato in un corso chiamato "Introduzione agli algoritmi". Ma forse hai coperto un trucco in classe che lo rende banale.

Il mio algoritmo proposto è il seguente:

Una somma è divisibile per n se aggiungi solo riassunti che sono multipli di n.

Prima di iniziare crei una hashmap con un int come chiave e un elenco di indici come valore. È inoltre possibile creare un elenco di risultati contenente indici.

Quindi passare in rassegna l'array e aggiungere tutti gli indici che mod n è zero all'elenco dei risultati. Per ogni altro indice, procedi come segue:

Sottrai il valore mod n di questo indice da n. Questo risultato è la chiave per la tua hashmap che memorizza gli indici per gli elementi con il valore richiesto. Ora aggiungi questo indice all'elenco nella hashmap e vai avanti.

Dopo aver terminato il loop sull'array, si calcola l'output. Puoi farlo ordinando ogni elenco nella hashmap in base al valore a cui punta l'indice. Ora consideri ogni coppia nella hashmap sommando fino a n. Quindi se n = 7 cerchi l'hashmap per 3 e 4. Se hai una voce in entrambi prendi i due valori più grandi rimuovili dai loro elenchi e aggiungili al tuo elenco dei risultati.

Ultima raccomandazione: non ho ancora testato l'algoritmo, scrivete un testcase su di esso usando un algoritmo a forza bruta.

utilizzare questo metodo DP da ( /programming/4487438/ma maximum - sum- of-non- consecutive - elements ? rq=1 ):

Dato un array A [0..n], sia M (i) la soluzione ottimale usando gli elementi con indici 0..i. Quindi M (-1) = 0 (utilizzato nella ricorrenza), M (0) = A [0] e M (i) = max (M (i - 1), M (i - 2) + A [i ]) per i = 1, ..., n. M (n) è la soluzione che vogliamo. Questo è O (n) . È possibile utilizzare un altro array per memorizzare la scelta effettuata per ciascun sottoproblema e quindi ripristinare gli elementi effettivi scelti.

Cambia la ricorsione in M ​​(i) = max (M (i - 1), M (i - 2) + A [i]) tale che sia memorizzato solo se è divisibile per N