Tengo un conjunto ordenado de N enteros. ¿El elemento más frecuente de la matriz parece mayor o igual que N / 3 veces? ¿Cuál es la forma más rápida de encontrar este número entero?

Answer 1

Si la matriz es A, los posibles candidatos para el elemento más frecuente son:
A [0], A [N / 3], A [2N / 3], A [N – 1]

(Gracias a Tim Converse por señalar los casos que había pasado por alto en mi respuesta anterior)
Hay 8 situaciones posibles:
caso 1: X = A [0] = A [N / 3] pero X! = A [2N / 3]! = A [N-1]
caso 2: X = A [N / 3] = A [2N / 3]
caso 3: X = A [2N / 3] = A [N-1] pero X! = A [N / 3]! = A [0]
caso 4: X = A [0] = A [N / 3] = A [2N / 3]! = A [N-1]
caso 5: X = A [N / 3] = A [2N / 3] = A [N-1]! = A [0]
caso 6: X = A [0] = A [N / 3] = A [2N / 3] = A [N-1]
caso 7: X = A [0] = A [N / 3] e Y = A [2N / 3] = A [N-1] y X! = Y
caso 8: A [0]! = A [N / 3]! = A [2N / 3]! = A [N-1]

Los casos 1,3,7 y 8 requieren que eliminemos a los candidatos al examinar localmente cada uno de estos elementos. Para los casos 2,4,5 y 6, la respuesta es inmediata.

Este algoritmo es O (1) en el mejor de los casos y O (N) en el peor.

Answer 2

  // Tiempo lineal, espacio constante
 // Complejidad del tiempo: O (n / 3) = O (n)
 // Complejidad espacial: O (1)
 // Asume que solo hay 1 elemento
 static int Find2 (fuente int [])
     {
         if (fuente == nulo)
             lanzar una nueva ArgumentNullException ("fuente");

         var len = source.Length;

         if (len == 0) devuelve -1;
         if (len == 1) fuente de retorno [0];
         si (len == 2)
         {
             return ((fuente [0] == fuente [1])? fuente [0]: -1);
         }

         var candidato0 = fuente [0];
         var candidato1 = fuente [(int) len / 3];
         var candidato2 = fuente [(int) 2 * len / 3];
         var candidato3 = fuente [len - 1];

         if (candidato0 == candidato1) devuelve candidato0;
         if (candidato1 == candidato2) devuelve candidato1;
         if (candidato2 == candidato3) devuelve candidato2;

         var diff = ((int) len / 3) + 1;
         para (int i = 0; i <= (int) len / 3; i ++)
         {
             if (fuente [i] == fuente [i + diff]) devolver fuente [i];

             if (fuente [len - 1 - i] == fuente [len - 1 - i - diff]) devuelve la fuente [len - 1 - i];
         }

         volver -1;
     }

Answer 3

Como señala Arun, si algún elemento de la matriz aparece al menos N / 3 veces, entonces uno de A [0], A [N / 3], A [2N / 3] debe ser ese elemento.

Para verificar cuál de los cuatro aparece realmente más, podemos usar la búsqueda binaria: para cualquier elemento x, podemos ver cuántas veces aparece en la matriz mediante la búsqueda binaria para el inicio y el final de la subsecuencia de la matriz que consiste de todas las copias de x. Así que solo hacemos esto para cada A [0], A [N / 3], A [2N / 3] para averiguar cuántas veces aparece cada uno.