Sottoinsieme massimo a coppie non divisibile per

Ho un insieme di numeri e desidero calcolare il sottoinsieme massimo in modo tale che la somma di due dei suoi elementi non sia divisibile per un numero intero $K$. Ho provato a risolvere questo problema, ma ho trovato la soluzione quadratica, che non è una risposta efficiente.
$K < 100, N < 10000$, dove $N$ è il numero di elementi e $K$è dato costante. C'è di meglio della soluzione quadratica?

In effetti esiste un algoritmo di tempo lineare per questo. Hai solo bisogno di usare alcuni concetti di base della teoria dei numeri. Dati due numeri$n_1$ e $n_2$, la loro somma è divisibile per $K$, solo se la somma del resto è divisibile per $K$. In altre parole,

Il secondo concetto che devi considerare è quello, la somma di due numeri $r_1 \neq r_2$ è $K$, solo se uno di questi è strettamente più piccolo di $K/2$ e l'altro non è inferiore a $K/2$. In altre parole,

Il terzo concetto che devi considerare è quello, se la somma di due numeri $r_1 \neq r_2$ è $K$, entrambi si discostano $\lceil K/2 \rceil -1$ da un certo $k \leq \lceil K/2 \rceil$cioè

Quindi, per evey $k$ nel terzo concetto, è necessario inserire entrambi $r_1$ o $r_2$nel set di soluzioni, ma non entrambi. È consentito inserire uno dei numeri che sono effettivamente divisibili per$K$ e se $K$ è pari, puoi aggiungere solo un numero che sia il resto $K/2$.

Pertanto, ecco l'algoritmo.

Dato un set ${\cal N}=\{ n_1, n_2, \cdots, n_N \}$, troviamo il set di soluzioni ${\cal S},$

1. Prendere in considerazione ${\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. per $k \gets 1$ per $\lceil K/2 \rceil -1$:
4. $\hspace{1.3em}$ Se $count({\cal R},k) \geq count({\cal R},K-k)$:
5. $\hspace{2.6em}$ Aggiungi tutto $n_i$ per ${\cal S}$, tale che $r_i=k$
6. $\hspace{1.3em}$ altro:
7. $\hspace{2.6em}$ Aggiungi tutto $n_i$ per ${\cal S}$, tale che $r_i=K-k$
8. aggiungere solo uno $n_i$ per ${\cal S}$ tale che $r_i=0\hspace{1em}$// se esiste
9. Se $K$ è anche:
10. $\hspace{1.3em}$ aggiungere solo uno $n_i$ per ${\cal S}$ tale che $r_i=K/2\hspace{1em}$// se esiste
11. Produzione ${\cal S}$

L'algoritmo è piuttosto lungo, ma l'idea è molto semplice.

Considera un set S di dimensione n contenente tutti i numeri naturali distinti. Dobbiamo formare il sottoinsieme massimo da questo set. Usiamo una proprietà del modulo di base e aggiungiamo alcune deduzioni per risolvere il problema. Spero sia utile per tutti voi.

Per due numeri naturali N1 e N2: (N1 + N2) mod (K) = (R1 + R2) mod (K) dove R1 = N1modK e R2 = N2% K. 1. Se noi (N1 + N2) modK = 0 significa (R1 + R2)% K = 0. 2. Ciò significa che R1 + R2 deve essere uguale a K, 2K, 3K .... 3. Ma R1 è compreso tra 0 e K-1 e quindi anche R2, il che significa che la loro somma non può superare K-1 + K-1 = 2 (K-1). 4. Da 2 e 3 possiamo concludere che R1 + R2 deve essere uguale a K. 5. Inoltre, se R1 + R2 = K significa che entrambi devono essere uguali a K / 2 (possibile solo se K è pari) o uno di questi deve essere inferiore al piano [K / 2] e uno maggiore dello stesso. 6. Supponiamo che R1 = T e R2 = KT, se prendiamo un numero N1 da S il cui resto è R1 e qualsiasi numero N2 da S il cui resto è R2, la loro somma sarà divisibile per K. Pertanto il sottoinsieme Soluzione può avere entrambi numeri con resto R1 o quelli con resto R2 ma non entrambi.

Supponiamo ora di costruire un array R di dimensioni K con indice da 0 a K-1, l'elemento in ciascun indice che denota il numero di numeri nell'insieme S con resto (sulla divisione con K) uguale al numero di indice. Non possiamo avere più di 2 numeri con il resto 0 poiché la loro somma sarebbe divisibile per K, quindi dobbiamo inizializzare il nostro contatore con min (R [0], 1). Per T = 1 a T

Il codice per lo stesso algoritmo in C ++ è come mostrato di seguito:

#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;
}

Ho provato a tradurre in codice C #, il primo a contare solo le dimensioni dell'array del sottoinsieme e un altro compreso l'intero sottoinsieme (hash).

Contare:

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;
}

Con sottoinsieme:

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;
}