título cepillo LeetCode observa 1,260 título

Descripción Asunto:

darle una  m línea de  n cuadrícula bidimensional de columnas  grid y un número entero  k. Usted tendrá que  grid migrar  k veces. Cada vez que la operación "migración" dará lugar a las siguientes actividades:

 

• Situado  grid[i][j] elementos se moverán a  grid[i][j + 1].
• Situado  grid[i][n - 1] elementos se moverán a  grid[i + 1][0].
• Situado  grid[m - 1][n - 1] elementos se moverán a  grid[0][0].

 

Por favor regrese a  k cuadrícula bidimensional después de los tiempos de migración resultantes. Ejemplo:

  输入：grid= [[1,2,3], [4,5,6 ], [7,8,9]], k = 1 
  de la salida: [[9,1,2], [3,4,5], [ 6,7,8]]

  输入：grid= [[3,8,1,9], [19,7,2,5 ], [4,6,11,10], [12,0,21,13]], k = 4 
  de salida: [[ 12,0,21,13], [3,8,1,9], [19,7,2,5], [4,6,11,10]]

limitaciones:

• 1 <= grid.length <= 50
• 1 <= grid[i].length <= 50
• -1000 <= grid[i][j] <= 1000
• 0 <= k <= 100

Ideas de resolución de problemas:

　　Mi idea es matriz bidimensional abstracto en una secuencia unidimensional de números, luego se transfiere de acuerdo con los requisitos de El sujeto puede conocer es en realidad k veces Migrar después de este número de secuencia unidimensional de k números transferidos a la porción delantera de la secuencia de números, todo el proceso puede ser imaginado como un movimiento circular. Así que recurrí a las dos primeras matrices unidimensionales son almacenados elementos de NK y los elementos k, entonces estos dos array serie traversal, elemento de almacenamiento a la colección llegara a salir. El tiempo de complejidad de O (m * n + (m + n)). Código de la siguiente manera:

    Lista <Lista <entero >> res_list; 

    pública Lista <Lista <entero >> shiftGrid ( int [] [] rejilla, int k) {
         si (k% (grid.length * rejilla [0] .length) == 0 ) { 
            res_list = nueva LinkedList <> () ;
            para ( int [] g: rejilla) { 
　　　　　　　　　　
                // .. Entero [] gg = IntStream.of (g) .boxed () a cobro revertido (Collectors.toList ()) toArray (new Integer [0]); 
                Lista <entero> ls = IntStream.of (g) .boxed () a cobro revertido (Collectors.toList ()).; 
                res_list.add (LS); 
            } 
            Devolver res_list; 
        }
        int temp_len = grid.length * rejilla [0 ] .length; 
        k = k% (temp_len);
        int [] temp = nuevo  int [temp_len- k];
        int [] temp2 = nuevo  int [k];
        int index = 0 ;
        para ( int [] ints: cuadrícula) {
             para ( int anInt: ints) {
                 si (índice <(temp_len- k)) 
                    temp [index] = anInt;
                otra cosa { 

                    Temp 2 [índice- (temp_len-k)] = anInt; 
                } 
                Índice ++ ; 
            } 
        } 
        LinkedList <Integer> temp_list = nuevo LinkedList <> (); 
        res_list = nuevo LinkedList <> ();
        para ( int i = 0; i <= temp_len; i ++ ) {
             si (% Rejilla i [0] .length == 0 && (i> = rejilla [0 ] .length)) { 
                res_list.add (temp_list); 
                temp_list = nuevo LinkedList <> (); 
            } 
            si(i < k) 
                temp_list.add (temp2 [i]); 
            más  si (i < temp_len) 
                temp_list.add (temp [i - k]); 
        } 
        Devolver res_list; 
    }

nota:

　　Al escribir un programa cometió un error de algún conocimiento, que no se almacena en los tipos de datos básicos para la recogida, almacenamiento sólo puede referirse a objetos. Cada elemento de la colección es una variable de referencia, que contenidos reales se almacenan en la zona de apilamiento o método, pero el tipo de datos básico se le asigna en el espacio de memoria de pila, los datos en la pila pueden ser retirados en cualquier momento. Por lo tanto, por un embalaje, el tipo de objeto de base en el tipo de datos, la referencia de almacenamiento. Más conveniente, gracias a la desembalaje automático y la función de embalaje, la conversión de tipo de datos entre la base y los objetos correspondientes se vuelven muy conveniente, los tipos de datos básicos se pueden ajustar automáticamente en la memoria, el sistema de embalaje de forma automática como clases de contenedor y, a continuación, añadido al conjunto de ellos.

　　Sin embargo, en el programa de cálculo conjunto presentes ls, cada fila I adquirió matriz bidimensional de matriz unidimensional, cuando la matriz unidimensional I puede convertir directamente en un conjunto por Arrays.asList entonces ser almacenados secuencialmente mediante la mejora el bucle for los resultados compilados en una colección se producen errores, lo que sugiere ninguna instancia (s) de variable de tipo (s) existe para que int [] se ajusta a Entero mal, así que convertir elemento g de la matriz es del tipo de clases de envoltura, y luego en resultados conjunto, como se muestra en el código específico anteriormente.

 

Otra solución mejor: una operación de módulo

Esta solución es la solución Leetcode funcionario dado, por lo que aprender acerca de la complejidad del tiempo es O (m * n). ideas específicas son las siguientes:

　　Traslado de la matriz bidimensional de problemas, además del método analógico, un cálculo directo de la nueva posición del elemento de transferencia más eficiente. Calcular una nueva posición en dos pasos:

1. ¿Qué es la nueva columna?
2. ¿Cuál es la nueva línea?

　　Suponiendo una rejilla en tres filas y cinco columnas, ubicado en  i = 1  y  j = 3  Valor en la migración veces  K = 88 .

　　Paso uno: valores Calcular nuevo de columna

　　Después de la etapa de migración k, el k-ésimo valor de la columna cambia cada paso, un valor de columna va a cambiar, pero los elementos de la red no es infinito en la dirección transversal durante el movimiento cíclico es concebible, porque el número de columnas por movimiento es tan 5 5 elementos menores vuelvan a la posición original de la columna (nota de la posición de la columna, no la ubicación exacta).

　　Por lo tanto, el paso de migración k, la posición de columna del elemento puede ser calculada por (88 + 3) 5%, de modo que una nueva ubicación para la columna;

　　fórmula Resumen general: new_col = (j + k)% NUM_COLS, j un valor inicial de la columna para el elemento, NUM_COLS el número total de columnas de la cuadrícula.

　　Segundo paso: calcular el valor de una nueva línea

　　conversión de valores de fila con poca frecuencia, y sólo si el valor de la columna se convierte en la última columna de la fila 0 para que el valor será cambiado, mientras que el elemento es un movimiento circular en la dirección longitudinal, por lo que para determinar los nuevos valores de fila, determina a partir de la última columna mover al número de 0, el número de la informática móvil utiliza comercialmente en el presente documento línea.

　　Resumen de la fórmula general: NEW_ROW = (i + (j + k) / NUM_COLS)% num_rows, i los valores para el elemento de línea de salida, num_rows número de filas

　　Código es el siguiente:

público List <Lista <Integer >> shiftGrid ( int [] [] rejilla, int k) { 

        int númeroColumnas = rejilla [0 ] .length;
        int numRows = grid.length; 

        // Configuración de la lista 2d. 
        Lista <lista <Integer = >> newGrid nuevo ArrayList <> ();
        para ( int fila = 0; fila <numRows; fila ++ ) { 
            Lista <Integer> newRow = nuevo ArrayList <> (); 
            newGrid.add (newRow); 
            para ( int col = 0; col <númeroColumnas; col ++  ) {
                newRow.); 
            } 
        } 

        Para ( int fila = 0; fila <numRows; fila ++ ) {
             para ( int col = 0; col <númeroColumnas; col ++ ) {
                 int Newcol = (col + k)% númeroColumnas;
                int wrapAroundCount = (col + k) / númeroColumnas;
                int newRow = (fila + wrapAroundCount)% numRows; 
                newGrid.get (newRow) .set (Newcol, rejilla [fila] [col]); 
            } 
        } 

        Volver newGrid; 
    }

Nota: es indexado colección de listas, se puede acceder a través del índice de la colección.