Maximale Teilmenge paarweise nicht durch teilbar

Ich habe eine Menge von Zahlen und möchte die maximale Teilmenge so berechnen, dass die Summe von zwei beliebigen Elementen nicht durch eine ganze Zahl teilbar ist . Ich habe versucht, dieses Problem zu lösen, aber ich habe die quadratische Lösung gefunden, die keine effiziente Antwort ist. , wobei die Anzahl der Elemente ist und konstant gegeben ist. Gibt es eine bessere als eine quadratische Lösung?K < 100 , N < 10000 N $K$
$K < 100, N < 10000$$N$$K$

In der Tat gibt es dafür einen linearen Zeitalgorithmus. Sie müssen nur einige grundlegende Konzepte der Zahlentheorie verwenden. Bei zwei Zahlen und ist ihre Summe nur dann für teilbar , wenn die Summe ihres Restes für teilbar ist . Mit anderen Worten,n 2 K $n_1$$n_2$$K$$K$

Das zweite Konzept , dass Sie beachten müssen , das heißt, die Summe von zwei Zahlen ist , nur wenn einer von ihnen ist streng kleiner als und das andere ist nicht weniger als . Mit anderen Worten, K K / 2 K /$r_1 \neq r_2$$K$$K/2$$K/2$

Das dritte Konzept , dass Sie beachten müssen, ist , dass, wenn die Summe von zwei Zahlen ist , sie beide weichen von durch eine bestimmte dh K ⌈ K / 2 ⌉ - 1 k ≤ ⌈ K / 2 $r_1 \neq r_2$$K$$\lceil K/2 \rceil -1$$k \leq \lceil K/2 \rceil$

Also, für Evey im dritten Konzept, müssen Sie entweder setzen oder in der Lösungsmenge, aber nicht beide. Sie dürfen eine der Zahlen eingeben, die tatsächlich durch teilbar sind, und wenn ist, können Sie nur eine Zahl hinzufügen, deren Rest .r 1 r 2 K K K /$k$$r_1$$r_2$$K$$K$$K/2$

Daher ist hier der Algorithmus.

Wenn eine Menge ist, finden wir die LösungsmengeS${\cal N}=\{ n_1, n_2, \cdots, n_N \}$${\cal S},$

1. Betrachten Sie${\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. für zu :⌈ K / 2 ⌉ - $k \gets 1$$\lceil K/2 \rceil -1$
4. $\hspace{1.3em}$ if :$count({\cal R},k) \geq count({\cal R},K-k)$
5. $\hspace{2.6em}$ addiere alle zu , so dassS r i = $n_i$${\cal S}$$r_i=k$
6. $\hspace{1.3em}$ else:
7. $\hspace{2.6em}$ addiere alle zu , so dassS r i = K - $n_i$${\cal S}$$r_i=K-k$
8. füge nur ein zu so dass // falls vorhandenS r i = $n_i$${\cal S}$$r_i=0\hspace{1em}$
9. wenn ist:$K$
10. $\hspace{1.3em}$ füge nur ein , so dass // falls vorhandenS r i = K /$n_i$${\cal S}$$r_i=K/2\hspace{1em}$
11. Ausgabe${\cal S}$

Der Algorithmus ist ziemlich lang, aber die Idee ist sehr einfach.

Betrachten Sie eine Menge S der Größe n, die alle unterschiedlichen natürlichen Zahlen enthält. Wir müssen die maximale Teilmenge aus dieser Menge bilden. Wir verwenden eine grundlegende Modul-Eigenschaft und fügen ihr einige Abzüge hinzu, um das Problem zu lösen. Ich hoffe es ist hilfreich für euch alle.

Für zwei beliebige natürliche Zahlen N1 und N2: (N1 + N2) mod (K) = (R1 + R2) mod (K) wobei R1 = N1modK und R2 = N2% K. 1. Wenn wir (N1 + N2) modK = 0 sind, bedeutet dies (R1 + R2)% K = 0. 2. Das bedeutet, dass R1 + R2 entweder K, 2K, 3K ... sein muss. 3. Aber R1 liegt zwischen 0 und K-1 und R2 auch, was bedeutet, dass ihre Summe K-1 + K-1 nicht überschreiten kann = 2 (K-1). 4. Aus 2 und 3 können wir schließen, dass R1 + R2 gleich K sein muss. 5. Wenn R1 + R2 = K ist, bedeutet dies, dass entweder beide gleich K / 2 sein müssen (nur möglich, wenn K gerade ist) oder einer von ihnen muss kleiner als der Boden [K / 2] und einer größer als derselbe sein. 6. Angenommen, R1 = T und R2 = KT, wenn wir eine beliebige Zahl N1 von S nehmen, deren Rest R1 ist, und eine beliebige Zahl N2 von S, deren Rest R2 ist, dann ist ihre Summe durch K teilbar. Daher kann die Lösungsuntermenge entweder diese haben Zahlen mit Rest R1 oder solche mit Rest R2, aber nicht beide.

Angenommen, wir konstruieren ein Array R der Größe K mit den Indizes 0 bis K-1. Das Element in jedem Index gibt die Anzahl der Zahlen in der Menge S an, wobei der Rest (bei Division mit K) gleich der Indexnummer ist. Wir können nicht mehr als 2 Zahlen mit ihrem Rest 0 haben, da ihre Summe durch K teilbar wäre, daher müssen wir unseren Zähler mit min (R [0], 1) initialisieren. Für T = 1 bis T.

Der Code für denselben Algorithmus in C ++ lautet wie folgt:

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

Ich habe versucht, in C # -Code zu übersetzen, wobei der erste nur die Größe des Subset-Arrays und der andere die gesamte (Hash-) Subset enthält.

Anzahl:

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

Mit Teilmenge:

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