Sous-ensemble maximum par paire non divisible par

Je un ensemble de nombres, et souhaite calculer le sous - ensemble maximal de telle sorte que la somme de deux quelconques des éléments de ce n'est pas divisible par un nombre entier . J'ai essayé de résoudre ce problème, mais j'ai trouvé la solution quadratique, qui n'est pas une réponse efficace. , où est le nombre d'éléments et est donné constant. Y a-t-il une solution meilleure que quadratique?$K$
$K < 100, N < 10000$$N$$K$

En effet, il existe un algorithme de temps linéaire pour cela. Il vous suffit d'utiliser certains concepts de base de la théorie des nombres. Étant donné deux numéros et , leur somme est divisible à , que si la somme de leur reste est divisible à . En d'autres termes,$n_1$$n_2$$K$$K$

Le deuxième concept que vous devez considérer est que la somme de deux nombres est , uniquement si l'un d'eux est strictement inférieur à et l'autre n'est pas inférieur à . En d'autres termes,$r_1 \neq r_2$$K$$K/2$$K/2$

Le troisième concept que vous devez considérer est que, si la somme de deux nombres est , ils s'écartent tous les deux de d'un certain , c'est à dire,$r_1 \neq r_2$$K$$\lceil K/2 \rceil -1$$k \leq \lceil K/2 \rceil$

Donc, pour evey dans le troisième concept, vous devez mettre ou dans l'ensemble de solutions, mais pas les deux. Vous êtes autorisé à mettre l'un des nombres qui sont réellement divisibles par et si est pair, vous ne pouvez ajouter qu'un seul nombre dont le reste est .$k$$r_1$$r_2$$K$$K$$K/2$

Voici donc l'algorithme.

Étant donné un ensemble , trouvons l'ensemble de solution${\cal N}=\{ n_1, n_2, \cdots, n_N \}$${\cal S},$

1. Considérons${\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. pour à :$k \gets 1$$\lceil K/2 \rceil -1$
4. $\hspace{1.3em}$ si :$count({\cal R},k) \geq count({\cal R},K-k)$
5. $\hspace{2.6em}$ ajoutez tous les à , de telle sorte que$n_i$${\cal S}$$r_i=k$
6. $\hspace{1.3em}$ sinon:
7. $\hspace{2.6em}$ ajoutez tous les à , de telle sorte que$n_i$${\cal S}$$r_i=K-k$
8. ajouter un seul à telle sorte que // s'il existe$n_i$${\cal S}$$r_i=0\hspace{1em}$
9. si est pair:$K$
10. $\hspace{1.3em}$ ajoutez un seul à telle sorte que // s'il existe$n_i$${\cal S}$$r_i=K/2\hspace{1em}$
11. Sortie${\cal S}$

L'algorithme est assez long, mais l'idée est très simple.

Considérons un ensemble S de taille n contenant tous les nombres naturels distincts. Nous devons former le sous-ensemble maximal de cet ensemble. Nous utilisons une propriété de module de base et y ajoutons quelques déductions pour résoudre le problème. J'espère que cela vous sera utile à tous.

Pour deux nombres naturels N1 et N2 quelconques: (N1 + N2) mod (K) = (R1 + R2) mod (K) où R1 = N1modK et R2 = N2% K. 1. Si nous (N1 + N2) modK = 0, cela signifie (R1 + R2)% K = 0. 2. Cela signifie que R1 + R2 doit être égal à K, 2K, 3K .... 3. Mais R1 se situe entre 0 et K-1 et R2 aussi, ce qui signifie que leur somme ne peut pas dépasser K-1 + K-1 = 2 (K-1). 4. De 2 et 3, nous pouvons conclure que R1 + R2 doit être égal à K. 5. De plus, si R1 + R2 = K, cela signifie que les deux doivent être égaux à K / 2 (uniquement possible si K est pair) ou l'un d'eux doit être inférieur au sol [K / 2] et l'autre supérieur au même. 6. Supposons que R1 = T et R2 = KT, si nous prenons tout nombre N1 de S dont le reste est R1 et tout nombre N2 de S dont le reste est R2, alors leur somme sera divisible par K. Par conséquent, le sous-ensemble Solution peut avoir les nombres avec le reste R1 ou ceux avec le reste R2 mais pas les deux.

Supposons maintenant que nous construisons un tableau R de taille K avec un index de 0 à K-1, l'élément de chaque index indiquant le nombre de nombres dans l'ensemble S avec un reste (sur division avec K) égal au numéro d'index. Nous ne pouvons pas avoir plus de 2 nombres avec leur reste 0 car leur somme serait divisible par K donc nous devons initialiser notre compteur avec min (R [0], 1). Pour T = 1 à T

Le code du même algorithme en C ++ est le suivant:

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

J'ai essayé de traduire en code C #, le premier à ne compter que la taille du tableau de sous-ensemble et un autre comprenant l'ensemble du sous-ensemble (hachage).

Compter:

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

Avec sous-ensemble:

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