Поиск дубликатов за O (n) время и O (1) пространство

Вход: задан массив из n элементов, который содержит элементы от 0 до n-1, причем любое из этих чисел встречается любое количество раз.

Цель: найти эти повторяющиеся числа за O (n) и использовать только постоянную память.

Например, пусть n будет 7, а array будет {1, 2, 3, 1, 3, 0, 6}, ответ должен быть 1 и 3. Я проверил аналогичные вопросы здесь, но в ответах использовались некоторые структуры данных, такие как HashSetи т. Д.

Какой-нибудь эффективный алгоритм для того же?

Это то, что я придумал, для чего не требуется дополнительный знаковый бит:

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

Первый цикл переставляет массив так, что если элемент xприсутствует хотя бы один раз, то одна из этих записей будет в позиции A[x].

Обратите внимание, что на первый взгляд он может не выглядеть O (n), но это так - хотя у него есть вложенный цикл, он все равно выполняется во O(N)времени. Обмен происходит только в том случае, если есть iтакой A[i] != i, и каждый обмен устанавливает по крайней мере один элемент такой A[i] == i, где раньше этого не было. Это означает, что общее количество свопов (и, следовательно, общее количество выполнений whileтела цикла) не больше N-1.

Второй цикл печатает значения, xдля которых A[x]не равно x- поскольку первый цикл гарантирует, что если xсуществует хотя бы один раз в массиве, один из этих экземпляров будет в A[x], это означает, что он печатает эти значенияx которых нет в массив.

(Ссылка на Ideone, чтобы вы могли с ней поиграть)

В блестящем ответе caf каждое число, которое встречается k раз в массиве, выводится k-1 раз. Это полезное поведение, но вопрос, возможно, требует, чтобы каждый дубликат был напечатан только один раз, и он намекает на возможность сделать это, не нарушая границы линейного времени / постоянного пространства. Это можно сделать, заменив его второй цикл на следующий псевдокод:

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

Это использует свойство, которое после выполнения первого цикла, если какое-либо значение mпоявляется более одного раза, то одно из этих появлений гарантированно находится в правильной позиции, а именноA[m] . Если мы будем осторожны, мы можем использовать это «домашнее» местоположение для хранения информации о том, были ли еще напечатаны дубликаты или нет.

В версии caf, когда мы просматривали массив, A[i] != iподразумевается, что A[i]это дубликат. В своей версии я полагаюсь на немного другой инвариант: это A[i] != i && A[A[i]] == A[i]означает, что A[i]это дубликат , которого мы раньше не видели. . (Если вы отбросите часть «что мы не видели раньше», то можно увидеть, что остальное подразумевается истинностью инварианта caf и гарантией того, что все дубликаты имеют некоторую копию в домашнем местоположении.) Это свойство сохраняется в начало (после завершения 1-го цикла caf), и я покажу ниже, что оно сохраняется после каждого шага.

Когда мы проходим через массив, успех со A[i] != iстороны теста означает, что это A[i] может быть дубликат, которого раньше не было. Если мы не видели этого раньше, то мы ожидаем, что A[i]домашнее местоположение будет указывать на себя - это то, что проверено во второй половинеif условия. Если это так, мы распечатываем его и изменяем домашнее местоположение, чтобы оно указывало обратно на этот первый найденный дубликат, создавая двухэтапный «цикл».

Для того, чтобы увидеть , что эта операция не изменяет наш инвариант, предположит , что m = A[i]для определенной позиции , iудовлетворяющей A[i] != i && A[A[i]] == A[i]. Очевидно, что изменение, которое мы делаем ( A[A[i]] = i), будет работать, чтобы предотвратить mвывод других не-домашних вхождений в качестве дубликатов, вызывая ifсбой второй половины их условий, но будет ли оно работать, когда будет iдостигнуто домашнее местоположение m,? Да, будет, потому что теперь, хотя в этом новом iмы обнаруживаем, что первая половина ifусловия A[i] != iистинна, вторая половина проверяет, является ли местоположение, на которое оно указывает, домашним местоположением, и обнаруживает, что это не так. В этой ситуации мы уже не знаем , является ли mили A[m]был повторяющееся значение, но мы знаем , что так или иначе,об этом уже сообщалось , потому что эти 2 цикла гарантированно не появятся в результате 1-го цикла caf. (Обратите внимание, что если m != A[m]тогда ровно одно из mи A[m]встречается более одного раза, а другое не встречается вообще.)

Вот псевдокод

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

Пример кода на C ++

Для относительно небольшого 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

Не C / C ++, но все равно

http://ideone.com/GRZPI

Не очень красиво, но, по крайней мере, легко увидеть свойства O (N) и O (1). В основном мы сканируем массив и для каждого числа видим, была ли соответствующая позиция помечена как уже виденная один раз (N) или уже увиденная несколько раз (N + 1). Если он помечен как «уже просмотренный один раз», мы распечатываем его и помечаем его как «уже просмотренный несколько раз». Если он не отмечен флажком, мы отмечаем его как «уже просмотренный один раз» и перемещаем исходное значение соответствующего индекса в текущую позицию (установка флажка является деструктивной операцией).

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

или еще лучше (быстрее, несмотря на двойной цикл):

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

Одно из решений в C:

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

Это время O (n) и сложность пространства O (1).

Предположим, что мы представляем этот массив как структуру данных однонаправленного графа - каждое число является вершиной, а его индекс в массиве указывает на другую вершину, образующую ребро графа.

Для еще большей простоты у нас есть индексы от 0 до n-1 и диапазон чисел от 0..n-1. например

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

0 (3) -> 3 (3) - это цикл.

Ответ: Просто обойдите массив, опираясь на индексы. если a [x] = a [y], то это цикл и, следовательно, дубликат. Перейти к следующему индексу и продолжить снова и так далее до конца массива. Сложность: O (n) время и O (1) пространство.

Крошечный код на Python для демонстрации описанного выше метода caf:

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. Получение исходного массива, хотя и не требуется, будет возможно, взяв каждую запись по модулю 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');
}

Ideone Link для тестирования.

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

Я быстро создал один образец приложения для игровой площадки для поиска дубликатов с временной сложностью 0 (n) и постоянным дополнительным пространством. Пожалуйста, проверьте URL-адрес Поиск дубликатов

IMP Вышеупомянутое решение работало, когда массив содержит элементы от 0 до n-1, причем любое из этих чисел встречается любое количество раз.

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

    }

Если массив не слишком велик, это решение проще. Он создает другой массив того же размера для отметки.

1 Создайте растровое изображение / массив того же размера, что и ваш входной массив

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

2 просканируйте ваш входной массив и увеличьте его счетчик в указанном выше массиве

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

3 Теперь просканируйте массив check_list и распечатайте дубликат либо один раз, либо столько раз, сколько они были дублированы.

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

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

Конечно, это занимает вдвое больше места, чем занимает решение, указанное выше, но эффективность по времени составляет O (2n), что в основном составляет O (n).