Subset maksimum berpasangan tidak dibagi oleh

Saya memiliki satu set angka, dan ingin menghitung subset maksimum sehingga jumlah dari dua elemen itu tidak habis dibagi integer . Saya mencoba untuk memecahkan masalah ini, tetapi saya telah menemukan solusi kuadratik, yang bukan respons yang efisien. , di mana adalah jumlah elemen dan diberikan konstan. Apakah ada solusi yang lebih baik daripada kuadratik?$K$
$K < 100, N < 10000$$N$$K$

Memang ada algoritma waktu linear untuk ini. Anda hanya perlu menggunakan beberapa konsep teori bilangan dasar. Mengingat dua nomor dan , jumlah mereka adalah dibagi ke , hanya jika jumlah sisa mereka dibagi ke . Dengan kata lain,$n_1$$n_2$$K$$K$

Konsep kedua yang perlu Anda pertimbangkan adalah bahwa, jumlah dua angka adalah , hanya jika salah satu dari mereka benar-benar lebih kecil dari dan yang lainnya tidak kurang dari . Dengan kata lain,$r_1 \neq r_2$$K$$K/2$$K/2$

Konsep ketiga yang perlu Anda pertimbangkan adalah bahwa, jika jumlah dua angka adalah , keduanya menyimpang dari oleh yaitu$r_1 \neq r_2$$K$$\lceil K/2 \rceil -1$$k \leq \lceil K/2 \rceil$

Jadi, untuk setiap dalam konsep ketiga, Anda perlu memasukkan atau dalam set solusi, tetapi tidak keduanya. Anda diizinkan untuk meletakkan salah satu angka yang sebenarnya dapat dibagi oleh dan jika genap, Anda dapat menambahkan hanya satu angka yang sisanya adalah .$k$$r_1$$r_2$$K$$K$$K/2$

Karena itu, berikut adalah algoritmenya.

Diberikan set , mari cari solusi set${\cal N}=\{ n_1, n_2, \cdots, n_N \}$${\cal S},$

1. Pertimbangkan${\cal R} = \{ r_1=(n_1 ~mod ~K), r_2=(n_2 ~mod ~K), \cdots, r_N=(n_N ~mod ~K) \}$
2. ${\cal S} \gets \emptyset$
3. untuk hingga :$k \gets 1$$\lceil K/2 \rceil -1$
4. $\hspace{1.3em}$ jika :$count({\cal R},k) \geq count({\cal R},K-k)$
5. $\hspace{2.6em}$ tambahkan semua ke , sedemikian rupa sehingga$n_i$${\cal S}$$r_i=k$
6. $\hspace{1.3em}$ lainnya:
7. $\hspace{2.6em}$ tambahkan semua ke , sedemikian rupa sehingga$n_i$${\cal S}$$r_i=K-k$
8. tambahkan hanya satu ke sedemikian rupa sehingga // jika ada$n_i$${\cal S}$$r_i=0\hspace{1em}$
9. jika genap:$K$
10. $\hspace{1.3em}$ tambahkan hanya satu ke sedemikian rupa sehingga // jika ada$n_i$${\cal S}$$r_i=K/2\hspace{1em}$
11. Keluaran${\cal S}$

Algoritma ini cukup panjang, tetapi idenya sangat sederhana.

Pertimbangkan seperangkat S ukuran n yang berisi semua bilangan asli. Kita harus membentuk subset maksimal dari set ini. Kami menggunakan properti modulus dasar dan menambahkan beberapa pengurangan untuk menyelesaikan masalah. Semoga bermanfaat buat kalian semua.

Untuk dua bilangan asli N1 dan N2: (N1 + N2) mod (K) = (R1 + R2) mod (K) di mana R1 = N1modK dan R2 = N2% K. 1. Jika kita (N1 + N2) modK = 0 artinya (R1 + R2)% K = 0. 2. Itu berarti R1 + R2 harus sama dengan K, 2K, 3K .... 3. Tetapi R1 terletak antara 0 & K-1 dan begitu juga R2, yang berarti jumlah mereka tidak dapat melebihi K-1 + K-1 = 2 (K-1). 4. Dari 2 dan 3 kita dapat menyimpulkan bahwa R1 + R2 harus sama dengan K. 5. Selanjutnya jika R1 + R2 = K itu berarti keduanya harus sama dengan K / 2 (hanya mungkin jika K genap) atau salah satunya harus lebih rendah dari lantai [K / 2] dan satu lebih besar dari yang sama. 6. Misalkan R1 = T dan R2 = KT, jika kita mengambil angka N1 dari S yang sisanya adalah R1 dan angka apa pun N2 dari S yang sisanya adalah R2 maka jumlah mereka akan habis dibagi oleh K. Oleh karena itu, himpunan bagian Solusi dapat memiliki keduanya angka dengan sisa R1 atau yang dengan sisa R2 tetapi tidak keduanya.

Sekarang Misalkan kita membangun R array ukuran K dengan indeks 0 hingga K-1, Elemen dalam setiap indeks menunjukkan jumlah angka dalam himpunan S dengan sisa (pada pembagian dengan K) sama dengan nomor indeks. Kita tidak dapat memiliki lebih dari 2 angka dengan sisa 0 karena jumlahnya akan habis dibagi oleh K oleh karena itu kita harus menginisialisasi penghitung kita dengan min (R [0], 1). Untuk T = 1 hingga T

Kode untuk algoritma yang sama dalam C ++ adalah seperti yang ditunjukkan di bawah ini:

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;


int main() {

    int n,k;
    cin>>n>>k;
    vector <int> a(n);
    vector <int> r(k,0);
    for(int i=0;i<n;i++)
    {   
        cin>>a[i];
        r[a[i]%k]++;
    }
    int ctr=min(1,r[0]);
    for(int a=1;a<(k/2+1);a++)
        {
            if(a!=k-a)
                ctr+=max(r[a],r[k-a]);
        }
    if(k%2==0&&r[k/2]!=0)
        ctr++;
    cout<<ctr;
    return 0;
}

Saya mencoba menerjemahkan ke kode C #, yang pertama hanya menghitung ukuran array subset dan lainnya termasuk seluruh subset (hash).

Menghitung:

static int nonDivisibleSubset(int k, int[] S)
{
    var r = new int[k];

    for (int i = 0; i < S.Length; i++)
        r[S[i] % k]++;

    int count = Math.Min(1, r[0]); 

    if (k % 2 == 0 && r[k / 2] != 0) 
        count++;                                    

    for (int j = 1; j <= k / 2; j++) 
    {                                                         
        if (j != k - j)
            count += Math.Max(r[j], r[k - j]);
    }

    return count;
}

Dengan subset:

static int nonDivisibleSubset(int K, int[] S)
{
    var r = new HashSet<int>();
    var d = S.GroupBy(gb => gb % K).ToDictionary(Key => Key.Key, Value => Value.ToArray());

    for (int j = 1; j <= K / 2; j++)
    {
        var c1 = d.GetValueOrDefault(j, new int[0]);
        var c2 = d.GetValueOrDefault(K - j, new int[0]);

        if (c1.Length == c2.Length) continue;

        r.UnionWith(c1.Length > c2.Length ? c1 : c2);
    }

    if (d.ContainsKey(0))
        r.Add(d[0].Max());

    if (K % 2 == 0 && d.ContainsKey(K / 2))
        r.Add(d[K / 2].Max());

    return r.Count;
}