Subconjunto máximo por pares não divisível por

Eu tenho um conjunto de números, e quer calcular o máximo subconjunto tal que a soma de quaisquer dois de seu elementos não é divisível por um inteiro . Tentei resolver esse problema, mas encontrei a solução quadrática, que não é uma resposta eficiente. , onde é o número de elementos e é constante. Existe melhor que solução quadrática?$K$
$K < 100, N < 10000$$N$$K$

De fato, existe um algoritmo de tempo linear para isso. Você só precisa usar alguns conceitos básicos da teoria dos números. Dados dois números e , sua soma é divisível para , somente se a soma de sua restante é divisível para . Em outras palavras,$n_1$$n_2$$K$$K$

O segundo conceito que você precisa considerar é que, a soma de dois números é , apenas se um deles for estritamente menor que e o outro não for menor que . Em outras palavras,$r_1 \neq r_2$$K$$K/2$$K/2$

O terceiro conceito que você precisa considerar é que, se a soma dos dois números for , ambos se desviarão de por um certo , ou seja,$r_1 \neq r_2$$K$$\lceil K/2 \rceil -1$$k \leq \lceil K/2 \rceil$

Portanto, para evey no terceiro conceito, você precisa colocar ou no conjunto de soluções, mas não os dois. Você pode colocar um dos números que são realmente divisíveis por e, se for par, você poderá adicionar apenas um número cujo restante seja .$k$$r_1$$r_2$$K$$K$$K/2$

Portanto, aqui está o algoritmo.

Dado um conjunto , vamos encontrar o conjunto de soluções${\cal N}=\{ n_1, n_2, \cdots, n_N \}$${\cal S},$

1. Considere${\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. para no :$k \gets 1$$\lceil K/2 \rceil -1$
4. $\hspace{1.3em}$ se :$count({\cal R},k) \geq count({\cal R},K-k)$
5. $\hspace{2.6em}$ adiciona todos os a , de modo que$n_i$${\cal S}$$r_i=k$
6. $\hspace{1.3em}$ else:
7. $\hspace{2.6em}$ adiciona todos os a , de modo que$n_i$${\cal S}$$r_i=K-k$
8. adicione apenas um a , para que // se existir$n_i$${\cal S}$$r_i=0\hspace{1em}$
9. se é par:$K$
10. $\hspace{1.3em}$ adicione apenas um a modo que // se existir$n_i$${\cal S}$$r_i=K/2\hspace{1em}$
11. Saída${\cal S}$

O algoritmo é bastante longo, mas a ideia é muito simples.

Considere um conjunto S de tamanho n contendo todos os números naturais distintos. Temos que formar o subconjunto máximo desse conjunto. Usamos uma propriedade de módulo básico e adicionamos algumas deduções para resolver o problema. Espero que seja útil para todos vocês.

Para quaisquer dois números naturais N1 e N2: (N1 + N2) mod (K) = (R1 + R2) mod (K) em que R1 = N1modK e R2 = N2% K. 1. Se nós (N1 + N2) modK = 0, isso significa (R1 + R2)% K = 0. 2. Isso significa que R1 + R2 deve ser igual a K, 2K, 3K .... 3. Mas R1 fica entre 0 e K-1 e R2 também, o que significa que sua soma não pode exceder K-1 + K-1 = 2 (K-1). 4. De 2 e 3, podemos concluir que R1 + R2 deve ser igual a K. 5. Além disso, se R1 + R2 = K significa que ambos devem ser iguais a K / 2 (somente possível se K for par) ou um deles deve ser menor que o piso [K / 2] e outro maior que o mesmo. 6. Suponha que R1 = T e R2 = KT, se pegarmos qualquer número N1 de S cujo restante é R1 e qualquer número N2 de S cujo restante é R2, sua soma será divisível por K. Portanto, o subconjunto Solução pode ter aqueles números com o restante R1 ou aqueles com o restante R2, mas não ambos.

Agora, suponha que construamos uma matriz R do tamanho K com o índice 0 a K-1. O elemento em cada índice indica o número de números no conjunto S com o restante (na divisão com K) igual ao número do índice. Não podemos ter mais de 2 números com o restante 0, pois sua soma seria divisível por K; portanto, devemos inicializar nosso contador com min (R [0], 1). Para T = 1 a T

O código para o mesmo algoritmo em C ++ é como mostrado abaixo:

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

Tentei traduzir para código C #, o primeiro a contar apenas o tamanho da matriz de subconjuntos e o outro incluindo o subconjunto inteiro (hash).

Contagem:

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

Com subconjunto:

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