Tập hợp con tối đa theo cặp không chia hết cho

Tôi có một tập hợp các số, và muốn tính toán tập hợp con tối đa sao cho tổng của bất kỳ hai trong số các yếu tố của nó là không chia hết cho một số nguyên . Tôi đã cố gắng giải quyết vấn đề này, nhưng tôi đã tìm ra giải pháp bậc hai, đó là phản ứng không hiệu quả. , trong đó N là số phần tử và K được cho không đổi. Có tốt hơn giải pháp bậc hai?K < 100 , N < 10000 N $K$
$K < 100, N < 10000$$N$$K$

Quả thực có một thuật toán thời gian tuyến tính cho việc này. Bạn chỉ cần sử dụng một số khái niệm lý thuyết số cơ bản. Với hai số và , tổng của chúng chia hết cho , chỉ khi tổng dư của họ là chia hết cho . Nói cách khác,n 2 K $n_1$$n_2$$K$$K$

Khái niệm thứ hai mà bạn cần xem xét là, tổng của hai số là , chỉ khi một trong số chúng nhỏ hơn và số kia không nhỏ hơn . Nói cách khác, K K / 2 K /$r_1 \neq r_2$$K$$K/2$$K/2$

Khái niệm thứ ba mà bạn cần xem xét là, nếu tổng của hai số là , cả hai đều lệch khỏi bởi một , I E, K ⌈ K / 2 ⌉ - 1 k ≤ ⌈ K / 2 $r_1 \neq r_2$$K$$\lceil K/2 \rceil -1$$k \leq \lceil K/2 \rceil$

Vì vậy, đối với evey trong khái niệm thứ ba, bạn cần đặt hoặc trong bộ giải pháp, nhưng không phải cả hai. Bạn được phép đặt một trong các số thực sự chia hết cho và nếu là số chẵn, bạn chỉ có thể thêm một số mà phần còn lại của nó là .r 1 r 2 K K K /$k$$r_1$$r_2$$K$$K$$K/2$

Do đó, đây là thuật toán.

Đặt một bộ , hãy tìm bộ giải phápS${\cal N}=\{ n_1, n_2, \cdots, n_N \}$${\cal S},$

1. Hãy xem xét${\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. cho đến :⌈ K / 2 ⌉ - $k \gets 1$$\lceil K/2 \rceil -1$
4. $\hspace{1.3em}$ nếu :$count({\cal R},k) \geq count({\cal R},K-k)$
5. $\hspace{2.6em}$ thêm tất cả vào , sao choS r i = $n_i$${\cal S}$$r_i=k$
6. $\hspace{1.3em}$ khác:
7. $\hspace{2.6em}$ thêm tất cả vào , sao choS r i = K - $n_i$${\cal S}$$r_i=K-k$
8. chỉ thêm một vào sao cho // nếu tồn tạiS r i = $n_i$${\cal S}$$r_i=0\hspace{1em}$
9. nếu chẵn:$K$
10. $\hspace{1.3em}$ chỉ thêm một vào sao cho // nếu tồn tạiS r i = K /$n_i$${\cal S}$$r_i=K/2\hspace{1em}$
11. Đầu ra${\cal S}$

Thuật toán khá dài, nhưng ý tưởng rất đơn giản.

Xét một tập hợp S có kích thước n chứa tất cả các số tự nhiên riêng biệt. Chúng ta phải tạo thành tập hợp con tối đa từ tập hợp này. Chúng tôi sử dụng một thuộc tính mô đun cơ bản và thêm một vài khoản khấu trừ vào nó để giải quyết vấn đề. Tôi hy vọng nó hữu ích cho tất cả các bạn.

Với hai số tự nhiên N1 và N2: (N1 + N2) mod (K) = (R1 + R2) mod (K) trong đó R1 = N1modK và R2 = N2% K. 1. Nếu chúng ta (N1 + N2) modK = 0 thì có nghĩa là (R1 + R2)% K = 0. 2. Điều đó có nghĩa là R1 + R2 phải bằng K, 2K, 3K .... 3. Nhưng R1 nằm giữa 0 & K-1 và R2 cũng vậy, có nghĩa là tổng của chúng không thể vượt quá K-1 + K-1 = 2 (K-1). 4. Từ 2 và 3, chúng ta có thể kết luận rằng R1 + R2 phải bằng K. 5. Hơn nữa nếu R1 + R2 = K có nghĩa là cả hai đều phải bằng K / 2 (chỉ có thể nếu K chẵn) hoặc một trong số chúng phải nhỏ hơn sàn [K / 2] và một lớn hơn cùng tầng. 6. Giả sử R1 = T và R2 = KT, nếu chúng ta lấy bất kỳ số N1 nào từ S có phần dư là R1 và bất kỳ số N2 nào từ S có phần dư là R2 thì tổng của chúng sẽ chia hết cho K. Do đó, tập con Giải pháp có thể có các số đó các số có số dư R1 hoặc các số còn lại R2 nhưng không phải cả hai.

Bây giờ Giả sử chúng ta xây dựng một mảng R có kích thước K với chỉ số từ 0 đến K-1, Phần tử trong mỗi chỉ mục biểu thị số lượng số trong tập S với phần còn lại (trên phép chia với K) bằng số chỉ mục. Chúng ta không thể có nhiều hơn 2 số với số còn lại là 0 vì tổng của chúng sẽ chia hết cho K do đó chúng ta phải khởi tạo bộ đếm của mình với min (R [0], 1). Cho T = 1 đến T

Mã cho cùng một thuật toán trong C ++ như dưới đây:

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

Tôi đã thử dịch sang mã C #, lần đầu tiên chỉ đếm kích thước của mảng tập hợp con và một mảng khác bao gồm toàn bộ tập hợp con (băm).

Đếm:

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

Với tập hợp con:

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