Tìm các bản sao trong O (n) thời gian và O (1) không gian

Dữ liệu vào: Cho một mảng n phần tử chứa các phần tử từ 0 đến n-1, với bất kỳ số nào trong số này xuất hiện với số lần bất kỳ.

Mục tiêu: Tìm các số lặp lại này trong O (n) và chỉ sử dụng không gian bộ nhớ không đổi.

Ví dụ: đặt n là 7 và mảng là {1, 2, 3, 1, 3, 0, 6}, câu trả lời phải là 1 & 3. Tôi đã kiểm tra các câu hỏi tương tự ở đây nhưng câu trả lời sử dụng một số cấu trúc dữ liệu như HashSetv.v.

Bất kỳ thuật toán hiệu quả cho cùng một?

Đây là những gì tôi đã nghĩ ra, không yêu cầu thêm bit dấu:

for i := 0 to n - 1
    while A[A[i]] != A[i] 
        swap(A[i], A[A[i]])
    end while
end for

for i := 0 to n - 1
    if A[i] != i then 
        print A[i]
    end if
end for

Vòng lặp đầu tiên hoán vị mảng để nếu phần tử xcó mặt ít nhất một lần, thì một trong các mục đó sẽ ở vị trí A[x].

Lưu ý rằng thoạt đầu nó có thể trông không đỏ mặt, nhưng nó - mặc dù nó có một vòng lặp lồng nhau, nó vẫn chạy O(N)đúng lúc. Một hoán đổi chỉ xảy ra nếu có một inhư vậy A[i] != i, và mỗi hoán đổi bộ ít nhất một yếu tố như vậy A[i] == i, nơi đó là không đúng sự thật trước. Điều này có nghĩa là tổng số lần hoán đổi (và do đó tổng số lần thực thi của phần whilethân vòng lặp) là nhiều nhất N-1.

Vòng lặp thứ hai in các giá trị của xmà A[x]không bằng x- kể từ khi đảm bảo vòng lặp đầu tiên mà nếu xtồn tại ít nhất một lần trong mảng, một trong những trường hợp sẽ có mặt tại A[x], điều này có nghĩa rằng nó sẽ in những giá trị củax mà không phải là trong hiện tại mảng.

(Liên kết Ideone để bạn có thể chơi với nó)

câu trả lời tuyệt vời của caf in ra mỗi số xuất hiện k lần trong mảng k-1 lần. Đó là hành vi hữu ích, nhưng câu hỏi được cho là yêu cầu mỗi bản sao chỉ được in một lần và anh ta ám chỉ đến khả năng thực hiện điều này mà không vượt qua giới hạn thời gian / không gian tuyến tính. Điều này có thể được thực hiện bằng cách thay thế vòng lặp thứ hai của anh ta bằng mã giả sau:

for (i = 0; i < N; ++i) {
    if (A[i] != i && A[A[i]] == A[i]) {
        print A[i];
        A[A[i]] = i;
    }
}

Điều này khai thác thuộc tính mà sau khi vòng lặp đầu tiên chạy, nếu bất kỳ giá trị nào mxuất hiện nhiều hơn một lần, thì một trong những lần xuất hiện đó được đảm bảo ở đúng vị trí, cụ thể làA[m] . Nếu cẩn thận, chúng ta có thể sử dụng vị trí "nhà riêng" đó để lưu trữ thông tin về việc có bản sao nào đã được in hay chưa.

Trong phiên bản của caf, khi chúng ta xem qua mảng, A[i] != ingụ ý rằng đó A[i]là một bản sao. Trong phiên bản của tôi, tôi dựa trên một bất biến hơi khác: A[i] != i && A[A[i]] == A[i]ngụ ý rằng đó A[i]là một bản sao mà chúng ta chưa từng thấy trước đây . (Nếu bạn bỏ phần "mà chúng tôi chưa từng thấy trước đây", phần còn lại có thể được thấy là ngụ ý bởi sự thật bất biến của caf và đảm bảo rằng tất cả các bản sao đều có một số bản sao ở vị trí nhà riêng.) Thuộc tính này có tại đầu tiên (sau khi kết thúc vòng lặp đầu tiên của caf) và tôi chỉ ra bên dưới rằng nó được duy trì sau mỗi bước.

Khi chúng ta đi qua mảng, thành công trong A[i] != imột phần của thử nghiệm ngụ ý rằng đó A[i] có thể là một bản sao chưa từng thấy trước đây. Nếu chúng tôi chưa từng nhìn thấy nó trước đây, thì chúng tôi hy vọng A[i]vị trí nhà của nó sẽ tự chỉ về chính nó - đó là những gì được kiểm tra trong nửa sau củaif điều kiện. Nếu đúng như vậy, chúng tôi sẽ in nó và thay đổi vị trí nhà để quay lại bản sao được tìm thấy đầu tiên này, tạo ra một "chu kỳ" gồm 2 bước.

Để thấy rằng thao tác này không làm thay đổi tính bất biến của chúng ta, hãy giả sử m = A[i]đối với một vị trí cụ thể ithỏa mãn A[i] != i && A[A[i]] == A[i]. Rõ ràng là thay đổi mà chúng tôi thực hiện ( A[A[i]] = i) sẽ hoạt động để ngăn các trường hợp không phải ở nhà khác xuất hiện mdưới dạng bản sao bằng cách khiến nửa sau của các ifđiều kiện của chúng không thành công, nhưng liệu nó có hoạt động khi iđến vị trí chính mkhông? Đúng vậy, bởi vì bây giờ, mặc dù ở thời điểm mới này, ichúng tôi thấy rằng nửa đầu của ifđiều kiện A[i] != i, là đúng, nhưng nửa sau sẽ kiểm tra xem vị trí mà nó trỏ đến có phải là vị trí nhà hay không và nhận thấy rằng nó không phải. Trong tình huống này, chúng ta không còn biết liệu mhoặcA[m] là giá trị trùng lặp, nhưng chúng ta biết rằng một trong hai cách,nó đã được báo cáo , bởi vì 2 chu kỳ này được đảm bảo không xuất hiện trong kết quả của vòng lặp đầu tiên của caf. (Lưu ý rằng nếu m != A[m]sau đó chính xác một trong số mvà A[m]xảy ra nhiều lần, và trường hợp kia hoàn toàn không xảy ra.)

Đây là mã giả

for i <- 0 to n-1:
   if (A[abs(A[i])]) >= 0 :
       (A[abs(A[i])]) = -(A[abs(A[i])])
   else
      print i
end for

Mã mẫu trong C ++

Đối với N tương đối nhỏ, chúng ta có thể sử dụng các phép toán div / mod

n.times do |i|
  e = a[i]%n
  a[e] += n
end

n.times do |i| 
  count = a[i]/n
  puts i if count > 1
end

Không phải C / C ++ nhưng dù sao

http://ideone.com/GRZPI

Không thực sự đẹp nhưng ít nhất bạn cũng dễ dàng nhìn thấy thuộc tính O (N) và O (1). Về cơ bản, chúng tôi quét mảng và đối với mỗi số, chúng tôi xem liệu vị trí tương ứng đã được gắn cờ là đã nhìn thấy một lần (N) hay đã được nhìn thấy nhiều lần (N + 1). Nếu nó được gắn cờ đã-xem-một lần, chúng tôi in nó và gắn cờ nó đã-xem-nhiều lần. Nếu nó không được gắn cờ, chúng tôi gắn cờ nó đã-nhìn thấy một lần và chúng tôi di chuyển giá trị ban đầu của chỉ mục tương ứng đến vị trí hiện tại (gắn cờ là một hoạt động phá hủy).

for (i=0; i<a.length; i++) {
  value = a[i];
  if (value >= N)
    continue;
  if (a[value] == N)  {
    a[value] = N+1; 
    print value;
  } else if (a[value] < N) {
    if (value > i)
      a[i--] = a[value];
    a[value] = N;
  }
}

hoặc tốt hơn nữa (nhanh hơn, mặc dù có vòng lặp kép):

for (i=0; i<a.length; i++) {
  value = a[i];
  while (value < N) {
    if (a[value] == N)  {
      a[value] = N+1; 
      print value;
      value = N;
    } else if (a[value] < N) {
      newvalue = value > i ? a[value] : N;
      a[value] = N;
      value = newvalue;
    }
  }
}

Một giải pháp trong C là:

#include <stdio.h>

int finddup(int *arr,int len)
{
    int i;
    printf("Duplicate Elements ::");
    for(i = 0; i < len; i++)
    {
        if(arr[abs(arr[i])] > 0)
          arr[abs(arr[i])] = -arr[abs(arr[i])];
        else if(arr[abs(arr[i])] == 0)
        {
             arr[abs(arr[i])] = - len ;
        }
        else
          printf("%d ", abs(arr[i]));
    }

}
int main()
{   
    int arr1[]={0,1,1,2,2,0,2,0,0,5};
    finddup(arr1,sizeof(arr1)/sizeof(arr1[0]));
    return 0;
}

Đó là độ phức tạp thời gian O (n) và không gian O (1).

Giả sử rằng chúng ta trình bày mảng này dưới dạng cấu trúc dữ liệu đồ thị đơn hướng - mỗi số là một đỉnh và chỉ số của nó trong mảng hướng đến một đỉnh khác tạo thành một cạnh của đồ thị.

Để đơn giản hơn, chúng ta có các chỉ số từ 0 đến n-1 và phạm vi số từ 0..n-1. ví dụ

   0  1  2  3  4 
 a[3, 2, 4, 3, 1]

0 (3) -> 3 (3) là một chu kỳ.

Trả lời: Chỉ cần duyệt qua mảng dựa vào các chỉ số. nếu a [x] = a [y] thì đó là một chu kỳ và do đó sẽ trùng lặp. Bỏ qua chỉ mục tiếp theo và tiếp tục lặp lại và tiếp tục như vậy cho đến khi kết thúc mảng. Độ phức tạp: O (n) thời gian và O (1) không gian.

Một mã python nhỏ để chứng minh phương pháp của caf ở trên:

a = [3, 1, 1, 0, 4, 4, 6] 
n = len(a)
for i in range(0,n):
    if a[ a[i] ] != a[i]: a[a[i]], a[i] = a[i], a[a[i]]
for i in range(0,n):
    if a[i] != i: print( a[i] )

Có thể dễ dàng nhìn thấy thuật toán trong hàm C sau đây. Truy xuất mảng ban đầu, mặc dù không bắt buộc, sẽ có thể thực hiện với mỗi mục nhập modulo n .

void print_repeats(unsigned a[], unsigned n)
{
    unsigned i, _2n = 2*n;
    for(i = 0; i < n; ++i) if(a[a[i] % n] < _2n) a[a[i] % n] += n;
    for(i = 0; i < n; ++i) if(a[i] >= _2n) printf("%u ", i);
    putchar('\n');
}

Liên kết Ideone để thử nghiệm.

static void findrepeat()
{
    int[] arr = new int[7] {0,2,1,0,0,4,4};

    for (int i = 0; i < arr.Length; i++)
    {
        if (i != arr[i])
        {
            if (arr[i] == arr[arr[i]])
            {
                Console.WriteLine(arr[i] + "!!!");
            }

            int t = arr[i];
            arr[i] = arr[arr[i]];
            arr[t] = t;
        }
    }

    for (int j = 0; j < arr.Length; j++)
    {
        Console.Write(arr[j] + " ");
    }
    Console.WriteLine();

    for (int j = 0; j < arr.Length; j++)
    {
        if (j == arr[j])
        {
            arr[j] = 1;
        }
        else
        {
            arr[arr[j]]++;
            arr[j] = 0;
        }
    }

    for (int j = 0; j < arr.Length; j++)
    {
        Console.Write(arr[j] + " ");
    }
    Console.WriteLine();
}

Tôi đã nhanh chóng tạo một ứng dụng sân chơi mẫu để tìm kiếm các bản sao với độ phức tạp thời gian 0 (n) và không gian thừa không đổi. Vui lòng kiểm tra url Tìm bản sao

Giải pháp IMP ở trên hoạt động khi một mảng chứa các phần tử từ 0 đến n-1, với bất kỳ số nào trong số này xuất hiện bất kỳ số lần nào.

private static void printRepeating(int arr[], int size) {
        int i = 0;
        int j = 1;
        while (i < (size - 1)) {
            if (arr[i] == arr[j]) {
                System.out.println(arr[i] + " repeated at index " + j);
                j = size;
            }
            j++;
            if (j >= (size - 1)) {
                i++;
                j = i + 1;
            }
        }

    }

Nếu mảng không quá lớn, giải pháp này đơn giản hơn, Nó tạo một mảng khác có cùng kích thước để đánh dấu.

1 Tạo một bitmap / mảng có cùng kích thước với mảng đầu vào của bạn

 int check_list[SIZE_OF_INPUT];
 for(n elements in checklist)
     check_list[i]=0;    //initialize to zero

2 quét mảng đầu vào của bạn và tăng số lượng của nó trong mảng trên

for(i=0;i<n;i++) // every element in input array
{
  check_list[a[i]]++; //increment its count  
}  

3 Bây giờ, hãy quét mảng check_list và in bản sao một lần hoặc nhiều lần chúng đã được sao chép

for(i=0;i<n;i++)
{

    if(check_list[i]>1) // appeared as duplicate
    {
        printf(" ",i);  
    }
}

Tất nhiên, nó tốn gấp đôi không gian tiêu thụ bởi giải pháp đưa ra ở trên, nhưng hiệu suất thời gian là O (2n) về cơ bản là O (n).