Subconjunto máximo por pares no divisible por

Tengo un conjunto de números y quiero calcular el subconjunto máximo de modo que la suma de cualquiera de sus dos elementos no sea divisible por un entero $K$. Traté de resolver este problema, pero encontré la solución cuadrática, que no es una respuesta eficiente.
$K < 100, N < 10000$, dónde $N$ es el número de elementos y $K$se da constante ¿Hay una solución mejor que la cuadrática?

De hecho, hay un algoritmo de tiempo lineal para esto. Solo necesita usar algunos conceptos básicos de teoría de números. Dados dos números$n_1$ y $n_2$, su suma es divisible a $K$, solo si la suma de su resto es divisible a $K$. En otras palabras,

El segundo concepto que debe tener en cuenta es que, la suma de dos números $r_1 \neq r_2$ es $K$, solo si uno de ellos es estrictamente más pequeño que $K/2$ y el otro no es menos que $K/2$. En otras palabras,

El tercer concepto que debe tener en cuenta es que, si la suma de dos números $r_1 \neq r_2$ es $K$, ambos se desvían de $\lceil K/2 \rceil -1$ por cierto $k \leq \lceil K/2 \rceil$es decir,

Entonces, para todos $k$ en el tercer concepto, necesitas poner $r_1$ o $r_2$en el conjunto de soluciones, pero no en ambos. Se le permite poner uno de los números que son divisibles por$K$ y si $K$ es par, solo puede agregar un número cuyo resto es $K/2$.

Por lo tanto, aquí está el algoritmo.

Dado un conjunto ${\cal N}=\{ n_1, n_2, \cdots, n_N \}$, busquemos el conjunto de soluciones ${\cal S},$

1. Considerar ${\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 $k \gets 1$ a $\lceil K/2 \rceil -1$:
4. $\hspace{1.3em}$ Si $count({\cal R},k) \geq count({\cal R},K-k)$:
5. $\hspace{2.6em}$ añadir todo $n_i$ a ${\cal S}$tal que $r_i=k$
6. $\hspace{1.3em}$ más:
7. $\hspace{2.6em}$ añadir todo $n_i$ a ${\cal S}$tal que $r_i=K-k$
8. agrega solo uno $n_i$ a ${\cal S}$ tal que $r_i=0\hspace{1em}$// si existe
9. Si $K$ incluso:
10. $\hspace{1.3em}$ agrega solo uno $n_i$ a ${\cal S}$ tal que $r_i=K/2\hspace{1em}$// si existe
11. Salida ${\cal S}$

El algoritmo es bastante largo, pero la idea es muy simple.

Considere un conjunto S de tamaño n que contiene todos los números naturales distintos. Tenemos que formar el subconjunto máximo a partir de este conjunto. Usamos una propiedad de módulo básico y le agregamos algunas deducciones para resolver el problema. Espero que sea útil para todos ustedes.

Para dos números naturales N1 y N2: (N1 + N2) mod (K) = (R1 + R2) mod (K) donde R1 = N1modK y R2 = N2% K. 1. Si nosotros (N1 + N2) modK = 0 significa (R1 + R2)% K = 0. 2. Eso significa que R1 + R2 debe ser igual a K, 2K, 3K .... 3. Pero R1 se encuentra entre 0 y K-1 y R2 también, lo que significa que su suma no puede exceder K-1 + K-1 = 2 (K-1). 4. De 2 y 3 podemos concluir que R1 + R2 debe ser igual a K. 5. Además, si R1 + R2 = K eso significa que ambos deben ser iguales a K / 2 (solo posible si K es par) o uno de ellos debe ser menor que el piso [K / 2] y uno mayor que el mismo. 6. Suponga que R1 = T y R2 = KT, si tomamos cualquier número N1 de S cuyo resto es R1 y cualquier número N2 de S cuyo resto es R2, entonces su suma será divisible por K. Por lo tanto, el subconjunto de la Solución puede tener esos números con el resto R1 o aquellos con el resto R2 pero no ambos.

Ahora supongamos que construimos una matriz R de tamaño K con índice de 0 a K-1. El elemento en cada índice denota el número de números en el conjunto S con resto (en la división con K) igual al número de índice. No podemos tener más de 2 números con su resto 0 ya que su suma sería divisible por K, por lo tanto, debemos inicializar nuestro contador con min (R [0], 1). Para T = 1 a T

El código para el mismo algoritmo en C ++ es el que se muestra a continuación:

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

Intenté traducir al código C #, el primero en contar solo el tamaño de la matriz de subconjuntos y otro que incluye todo el subconjunto (hash).

Contar:

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