En büyük toplam n'ye bölünebilir

StackOverflow bu soruyu sordum , ama burada daha uygun bir yer olduğunu düşünüyorum.

Bu algoritma giriş ders bir sorun :

Bir dizi var $a$ ile $n$ pozitif (dizi sıralanacak gerekmez veya elemanlar benzersiz) tamsayılar. Bir sonuçları $O(n)$ ile bölünebilen elemanlarının büyük toplamı bulmak için algoritma $n$ .

Örnek: $a = [6, 1, 13, 4, 9, 8, 25], n = 7$ . Cevap $56$ ( elementli $6, 13, 4, 8, 25$)

Dinamik programlama kullanarak ve 0 , 1 , 2 , kalan en büyük toplamı depolayarak de bulmak nispeten kolaydır . . . , n - 1 .$O(n^2)$$0, 1, 2,..., n - 1$

Ayrıca, dikkati bitişik bir eleman dizisiyle kısıtlarsak , kısmi toplamları modulo n depolayarak zamanında bu tür optimal diziyi bulmak kolaydır : let S [ i ] = a [ 0 ] + a [ 1 ] + ⋯ + bir [ ı ] , her bir geri kalan için r büyük endeks hatırlamak j öyle ki S [ j ] ≡ $O(n)$$n$$S[i]=a[0]+a[1]+\dots + a[i]$$r$$j$ ve daha sonra her bir i için S [ j ] - S [ i ] olduğunu düşünürsünüz; burada j , r = S [ i ] mod n'ye karşılık gelen dizindir .$S[j] \equiv r \pmod{n}$$i$$S[j]-S[i]$$j$$r=S[i] \bmod n$

Fakat genel durum için -zamanlı bir çözüm var mı? Herhangi bir öneriniz takdir edilecektir! Bunun lineer cebirle uğraşacak bir şey olduğunu düşünüyorum ama tam olarak ne olduğundan emin değilim.$O(n)$

Alternatif olarak, bu zamanında yapılabilir mi?$O(n \log n)$

İşte birkaç rastgele fikir:

• Dinamik programlama algoritması, en büyük toplam yerine en küçük toplamı aramak için çevrilebilir. Sonunda, bir sıfıra uygun yerine, tüm dizinin toplamının geri kalanına uygun bir toplam arıyorsunuz. Elemanları artan sırayla işlersek, bu bazen dinamik algoritmanın tüm diziyi işlemeden önce sonlanmasına izin verir.

  Eğer k öğelerini işlersek maliyet olur . Orada değil sınırı daha düşük Q ( n log n ) biz tüm öğeleri sıralamak yok çünkü bu algoritmaya. Sadece O ( n log k ) zaman alır$O(n k)$$k$$\Omega(n \log n)$$O(n \log k)$ en küçük unsurları.$k$

• Kümeyi larget boyutuyla önemsediğimizde, en büyük toplamı olan küme yerine, zaman. Etki alanı aralığı sınırlı olduğunda 3SUM'da yapılanlara benzer . (Not: ikili arama yapmak için tekrarlanan kareleri kullanın, aksi takdirde O ( n k ( log n ) ( log log n ) elde edersiniz $O(n (\log n)^2 (\log \log n))$$O(n k (\log n) (\log \log n))$$k$ atlanan öğelerin sayısıdır.)

• Ne zaman kompozit olduğunu ve hemen hemen tüm kalıntılarını birinin birkaç katıdır n 'in faktörler, önemli zaman o faktörün katları olmayan kalanları odaklanarak kaydedilebilir.$n$$n$

• Bir kalıntı rçok yaygın olduğunda veya yalnızca birkaç kalıntı olduğunda, 'buradan başlarsanız ve ilerlemeye devam ederseniz bir sonraki açık alanın izlenmesi r' bilgileri, açık noktalara atlamak için çok fazla tarama kaydedebilir saati.

• Bir günlük faktörünü yalnızca erişilebilirliği izleyerek ve bit maskelerini (çevrilmiş dinamik algoritmada) kullanarak ve ardından hedef kalana ulaştığınızda geri izleyerek tıraş edebilirsiniz .

• Dinamik programlama algoritması paralel olarak çalıştırılmaya çok uygundur. Her tampon yuvası için bir işlemci ile değerine inebilirsiniz . Alternatif olarak, O ( n 2 ) genişliğini kullanarak ve yinelemeli toplama yerine bölünmeyi ve fethetmeyi kullanarak , devre derinliği maliyeti tamamen O'ya ( log 2 n ) kadar inebilir .$O(n)$$O(n^2)$$O(\log^2 n)$

• (Meta) Size verilen sorunun bitişik meblağlardan kaynaklandığından şüpheleniyorum . Asıl sorunla bağlantı kurduysanız, bunu doğrulamak kolay olacaktır. Aksi takdirde, "Algoritmalara Giriş" adlı bir derste atandığı göz önüne alındığında, bu sorunun ne kadar zor olduğuna çok şaşırdım. Ama belki de sınıfta bunu önemsiz yapan bir numara yaptınız.

Önerilen algoritmam aşağıdaki gibi gidiyor:

Yalnızca n'nin katları olan toplamlar eklerseniz bir toplam n ile bölünebilir.

Başlamadan önce int as anahtarına sahip bir hashmap ve değer olarak endekslerin bir listesini oluşturursunuz. Ayrıca indeksler içeren bir sonuç listesi de oluşturabilirsiniz.

Daha sonra dizi üzerinde döngü ve mod n sıfır olan her dizini sonuç listenize ekleyin. Diğer tüm dizinler için aşağıdakileri yaparsınız:

Bu dizinin n mod değerini n'den çıkarırsınız. Bu sonuç, gerekli değere sahip elemanlar için endeksleri saklayan hashsinizin anahtarıdır. Şimdi, bu dizini hashmap içindeki listeye ekleyip devam edersiniz.

Dizi üzerinde döngü bittikten sonra çıktı hesaplar. Bunu, hashmap içindeki her listeyi dizinin işaret ettiği değere göre sıralayarak yaparsınız. Şimdi hashmap'taki her çifti n'ye kadar toplarsınız. Eğer n = 7 ise hashmap'i 3 ve 4 için ararsanız, her ikisinde de bir girişiniz varsa, en büyük iki değeri alırsınız, bunları listelerinden kaldırın ve sonuç listenize ekleyin.

Son öneri: algoritmayı hala test etmedi, kaba kuvvet algoritması kullanarak buna karşı bir testcase yazın.

bu DP yöntemini ( /programming/4487438/maximum-sum-of-non-consecutive-elements?rq=1 ) adresinden kullanın :

A [0..n] dizisi verildiğinde, 0..i indekslerine sahip elemanları kullanarak M (i) en uygun çözüm olsun. Sonra M (-1) = 0 (rekürrensde kullanılır), M (0) = A [0] ve M (i) = maks. (M (i - 1), M (i - 2) + A [i ]) i = 1, ..., n için. M (n) istediğimiz çözümdür. Bu O (n) . Her alt sorun için hangi seçeneğin yapıldığını saklamak için başka bir dizi kullanabilir ve böylece seçilen gerçek öğeleri kurtarabilirsiniz.

Özyinelemeyi yalnızca N ile bölünebilirse depolanacak şekilde M (i) = maks (M (i - 1), M (i - 2) + A [i]) olarak değiştirin