Introducción
Siguiente: LeetCode Algorithm Training-String
Originalmente quería comenzar con el nivel principiante e intermedio y los algoritmos de entrevistas corporativas, pero al final optamos por comenzar desde lo básico, porque no cepillamos preguntas con el propósito de cepillar preguntas, sino ejercitar una especie de algoritmo pensando en el proceso de cepillado de preguntas, después de mucho entrenamiento. Forme una visión única del algoritmo, cultive la sensibilidad al algoritmo, vea el problema, un plan para resolver el problema puede aparecer en el cerebro y, lentamente, genere confianza desde el principio, y esto también es para el complejo algoritmo detrás Sentar las bases para ideas de resolución de problemas.
Introducción al algoritmo primario de LeetCode
Si también quieres entrenar tu propio pensamiento algorítmico, también puedes unirte a mí, comenzando desde el algoritmo elemental, inicia tu viaje del algoritmo: algoritmo elemental .
Un poco de su propio pensamiento: no mire la respuesta después de leer la pregunta y luego recite la pregunta, de modo que la memoria del algoritmo implementado no sea fuerte, debe tener su propio pensamiento; y no escriba sobre IDEA al principio, Asegúrese de intentar escribirlo en la pizarra proporcionada por leetCode y finalmente colóquelo en IDEA para ver si hay algún problema, a fin de consolidar su uso y competencia básica de API; otro punto es ser audaz, no el costo de prueba y error en la entrevista Baja, intenta incorporar nuestras ideas al código.
Debido a problemas de espacio, el blog solo enumera ejemplos y sus propias respuestas de resolución de problemas. Para obtener más detalles, puede hacer clic directamente en el tema para ver.
Eliminar duplicados en una matriz ordenada
Problema Dada una matriz ordenada, debe eliminar los elementos repetidos en su lugar, de modo que cada elemento solo aparezca una vez y devuelva la nueva longitud de la matriz eliminada.
No utilice espacio adicional en la matriz, debe modificar la matriz de entrada in situ y completar con O (1) espacio adicional.
Ejemplo 1 :
Dada la matriz nums = [1,1,2], la
función debe devolver la nueva longitud 2, y los dos primeros elementos de la matriz original nums se modifican a 1, 2.
No necesita considerar los elementos de la matriz más allá de la nueva longitud.
Ejemplo 2 :
Dado nums = [0,0,1,1,1,2,2,3,3,4], la
función debe devolver la nueva longitud de 5, y los primeros cinco elementos de los números de matriz originales se modifican a 0 , 1, 2, 3, 4.
No necesita considerar los elementos de la matriz más allá de la nueva longitud.
mi respuesta
class Solution {
public int removeDuplicates(int[] nums) {
if (nums == null || nums.length == 0) return 0;
if (nums.length == 1) return 1;
int elem = nums[0];
int markIndex = 1;
//给定 nums = [0,0,1,1,1,2,2,3,3,4]
for (int i = 1; i < nums.length; i++) {
if (elem != nums[i]) {
nums[markIndex] = nums[i];
markIndex++;
elem = nums[i];
}
}
return markIndex;
}
}
Tiempo de ejecución: 1 ms
Consumo de memoria: 41,5 MB
El mejor momento para comprar y vender acciones II
Dada una matriz, su i-ésimo elemento es el precio de una acción determinada en el i-ésimo día.
Diseñe un algoritmo para calcular el máximo beneficio que puede obtener. Puede completar tantas transacciones como sea posible (comprar y vender acciones varias veces).
Nota: No puede participar en varias transacciones al mismo tiempo (debe vender las existencias anteriores antes de volver a comprar).
Ejemplo 1:
Entrada: [7,1,5,3,6,4]
Salida: 7
Explicación: Compre el segundo día (precio de las acciones = 1) y el tercer día (precio de las acciones = 5) Vender, este intercambio puede generar una ganancia = 5-1 = 4.
Luego, compre el cuarto día (precio de las acciones = 3) y venda el quinto día (precio de las acciones = 6) Este intercambio puede generar una ganancia = 6-3 = 3.
Ejemplo 2:
Entrada: [1,2,3,4,5]
Salida: 4
Explicación: Compre el primer día (precio de las acciones = 1) y venda el quinto día (precio de las acciones = 5) , Este intercambio puede generar una ganancia = 5-1 = 4.
Tenga en cuenta que no puede comprar acciones una tras otra en el primer y segundo día y luego venderlas.
Debido a que esto está involucrado en múltiples transacciones al mismo tiempo, debe vender las acciones anteriores antes de comprar nuevamente.
Ejemplo 3:
Entrada: [7,6,4,3,1]
Salida: 0
Explicación: En este caso, no se completa ninguna transacción, por lo que la ganancia máxima es 0.
public static int maxProfit(int[] prices) {
if (prices == null || prices.length == 0) return 0;
int maxProfit = 0;
int buyPrice = -1;
int sellPrice = -1;
//[7,1,5,3,6,4]
for (int i = 1; i < prices.length; i++) {
//涨
if (prices[i] >= prices[i - 1]) {
if (buyPrice == -1) {
buyPrice = prices[i - 1];
// System.out.println("buyPrice: " + buyPrice);
}
} else {
if (sellPrice == -1 && buyPrice != -1) {
sellPrice = prices[i - 1];
// System.out.println("sellPrice: " + sellPrice);
}
}
if (i == prices.length - 1 && sellPrice == -1 && buyPrice != -1) {
sellPrice = prices[prices.length - 1];
//System.out.println("sellPrice: " + sellPrice);
}
if (buyPrice != -1 && sellPrice != -1) {
maxProfit += (sellPrice - buyPrice);
buyPrice = -1;
sellPrice = -1;
}
}
return maxProfit;
}
Tiempo de ejecución: 23 ms
Consumo de memoria: 39,7 MB
Después de ejecutar, en comparación con el tiempo de ejecución de las estadísticas, descubrí que mi lógica posible es complicada. Registré el precio de compra cuando estaba a punto de subir y el precio de venta cuando estaba a punto de bajar, y lo calculé una y otra vez. Por analogía, si sigue subiendo, se utiliza el último precio como precio de venta y, finalmente, se superpone el rendimiento máximo cada vez.
Luego, en este momento, hice clic en el código de otra persona con un tiempo de ejecución de 1 ms, y fue muy simple. Solo pensé dónde habría un problema, y luego lo probé, y se convirtió en 1 ms después de eliminar System.output.println (). Muy feliz.
Después de la modificación:
tiempo de ejecución: 1 ms
consumo de memoria: 39,1 MB
Rotar la matriz
Dada una matriz, mueva los elementos de la matriz k posiciones a la derecha, donde k es un número no negativo.
Ejemplo 1:
Entrada: [1,2,3,4,5,6,7] yk = 3
Salida: [5,6,7,1,2,3,4]
Explicación:
Gire 1 paso hacia la derecha: [ 7,1,2,3,4,5,6]
Girar a la derecha 2 pasos: [6,7,1,2,3,4,5]
Girar a la derecha 3 pasos: [5,6,7,1, 2,3,4]
Ejemplo 2:
Entrada: [-1, -100,3,99] yk = 2
Salida: [3,99, -1, -100]
Explicación:
Girar a la derecha 1 paso: [99, -1, -100, 3]
Gire a la derecha por 2 pasos: [3,99, -1, -100] La
primera vez que escribe solo, no hay mejor manera que la violencia. Pero el tiempo de presentación y ejecución es demasiado largo para pasar.
Aunque se hace el juicio de zurdo o diestro, llevará mucho tiempo cuando ky la matriz sean muy grandes.
class Solution {
public static void rotate(int[] nums, int k) {
if (nums == null || nums.length == 0) return;
int realK = k % nums.length;
boolean right = true;
if (realK > (nums.length / 2)) {
right = false;
realK = nums.length - realK;
}
for (int i = 0; i < realK; i++) {
if (right) {
for (int j = 0; j < nums.length; j++) {
int t = nums[(j + 1) % nums.length];
nums[(j + 1) % nums.length] = nums[0];
nums[0] = t;
}
} else {
for (int j = nums.length - 1; j >= 1; j--) {
int t = nums[(j - 1) % nums.length];
nums[(j - 1) % nums.length] = nums[nums.length - 1];
nums[nums.length - 1] = t;
}
}
}
}
}
Cuando verifiqué la idea oficial de resolución de problemas por segunda vez, descubrí que el método de rotación es el mejor para entender. Luego lo escribí yo mismo, los volteé todos una vez y luego dividí la matriz en 0-ky k-length. k debe tomar el resto o excederá el tamaño de la matriz y luego pasará.
class Solution {
public void rotate(int[] nums, int k) {
if (nums == null || nums.length == 0) return;
reverse(nums, 0, nums.length);
reverse(nums, 0, k % nums.length);
reverse(nums, k % nums.length, nums.length);
}
public void reverse(int[] nums, int start, int end) {
int needReverse = (end - start) / 2;
for (int i = 0; i < needReverse; i++) {
int temp = nums[start + i];
nums[start + i] = nums[end - i - 1];
nums[end - i - 1] = temp;
}
}
}
Tiempo de ejecución: 0 ms
Consumo de memoria: 40,5 MB
También hay un método de reemplazo circular y otro método para usar matrices adicionales a expensas de espacio.
Aquí hay una introducción al reemplazo de anillos para ampliar el horizonte inferior:
reemplazo de anillos
Para evitar que la matriz cruce el límite, primero realice el resto de k.
Sondear la matriz desde cero, y luego almacenar en caché el primer número en prev, y usar la variable temporal temp para almacenar en caché el número en la posición actual + k;
reemplazar con prev al número en la posición actual + k, y luego asignar temp a prev Actualice el valor de prev, actualice la posición actual a actual + k y agregue 1 al número de conteo.
Debido a que necesitamos ajustar el número correspondiente a la posición correspondiente, solo los tiempos de duración deben estar bien, es decir, ajustar la posición una vez para cada número.
Cuando la corriente es igual al inicio, significa que el intercambio vuelve a la posición de inicio al final, que es equivalente a esta ruta de intercambio que ya hemos caminado una vez, necesitamos detener el intercambio actual y continuar el intercambio desde la siguiente posición, de lo contrario continuará funcionando infinitamente. ciclo.
Generalmente, en este caso, puede usar el siguiente método para estimar el número de intercambios reiniciados:
Cuando el máximo común divisor de longitud yk es igual a 1, el intercambio se puede completar en un recorrido; por
ejemplo, n = 5, k = 3
cuando la longitud y Cuando el máximo común divisor de k no es igual a 1: 1, el recorrido es el retorno de todos los elementos que no se pueden completar, y se requieren m (el máximo común divisor) tiempos
public static void rotate2(int[] nums, int k) {
k = k % nums.length;
int count = 0;
for (int i : nums) {
System.out.print(i + ",");
}
System.out.print("\n");
System.out.println("length: " + nums.length);
System.out.println("k: " + k);
for (int start = 0; count < nums.length; start++) {
System.out.println("-------------------");
int current = start;
int prev = nums[start];
System.out.println("缓存下来的数据 prev: " + prev);
do {
int next = (current + k) % nums.length;
System.out.print("当前位置: " + current + " 替换 ");
System.out.println(next + " 位置内容");
System.out.print("nums[" + next + "]:" + nums[next] + "-->");
int temp = nums[next];
nums[next] = prev;
prev = temp;
current = next;
count++;
System.out.println("nums[" + next + "]:" + nums[next]);
System.out.println("移动次数: " + count);
for (int i : nums) {
System.out.print(i + ",");
}
System.out.print("\n");
System.out.println("-------------------");
System.out.println("缓存下来的数据 prev: " + prev);
} while (start != current);
System.out.println("countend: " + count);
System.out.println("start: " + start);
}
}
Hay elementos duplicados
Dada una matriz de enteros, determine si hay elementos duplicados.
Si algún valor aparece al menos dos veces en la matriz, la función devuelve verdadero. Si cada elemento de la matriz es diferente, se devuelve falso.
Mi idea es ordenar primero y luego averiguar si hay los mismos números.
Hay otras formas de hacer esto, como usar HashSet.
public boolean containsDuplicate(int[] nums) {
if(nums == null || nums.length == 0 || nums.length == 1) return false;
Arrays.sort(nums);
int k = nums[0];
for(int i = 1 ; i< nums.length ; i++) {
if(k != nums[i]) {
k = nums[i];
} else{
return true;
}
}
return false;
}
Tiempo de ejecución: 4 ms
Consumo de memoria: 43,5 MB
Un número que aparece solo una vez
Dada una matriz de enteros no vacíos, cada elemento aparece dos veces excepto un elemento. Encuentra el elemento que aparece solo una vez.
Explicación:
Su algoritmo debe tener una complejidad de tiempo lineal. ¿Puedes hacer esto sin usar espacio extra?
Inspirado en la pregunta anterior, todavía debe ordenar primero. Después de ordenar, debe ser un par de pares, y luego un bucle, porque aparece en pares, comenzando desde el primer libro, si el primer y segundo registro son inconsistentes Si la repetición de la marca es falsa, el resultado directo es nums [i]; si el resultado está en el medio, es el primero y el segundo es el mismo, luego salte al siguiente par i = i + 1 seguido de i ++, si esta vez el siguiente Si los pares no son iguales, devuelve nums [i]; si la repetición anterior resulta ser el último par de juicios en la matriz, después de que i pasa i + 1, i es la penúltima posición, entonces se devuelve el último número.
public int singleNumber(int[] nums) {
if (nums.length == 1) return nums[0];
Arrays.sort(nums);
boolean repeat = false;
for (int i = 0; i < nums.length - 1; i++) {
if (nums[i] == nums[i + 1]) {
repeat = true;
i = i + 1;
}
if (repeat && i == nums.length - 2) {
return nums[i + 1];
}
if (!repeat) {
return nums[i];
}
if (repeat) {
repeat = false;
}
}
throw new IllegalArgumentException("Not found single elem");
}
Tiempo de ejecución: 4 ms
Consumo de memoria: 41 MB
Este lugar se siente como una coincidencia y simplemente lo inventó Después de leer la respuesta oficial, encontraron que tienen una solución más inteligente, que es usar XOR.
- Cualquier número y 0 son XOR, el resultado sigue siendo el número original, es decir, a ⊕ 0 = a.
- A cualquier número se le aplica XOR consigo mismo, y el resultado es 0, es decir, a⊕a = 0.
- La operación OR exclusiva satisface la ley conmutativa y la ley asociativa, a saber, a⊕b⊕a = b⊕a⊕a = b⊕ (a⊕a) = b⊕0 = b.
class Solution {
public int singleNumber(int[] nums) {
if(nums.length == 1) return nums[0];
int sum = 0;
for(int i : nums) {
sum ^=i;
}
return sum;
}
}
Tiempo de ejecución: 1 ms
Consumo de memoria: 40,4 MB El
tiempo de ejecución se reduce considerablemente.
La intersección de dos matrices II
Dadas dos matrices, escribe una función para calcular su intersección.
Ejemplo 1:
Entrada: nums1 = [1,2,2,1], nums2 = [2,2]
Salida: [2,2]
Ejemplo 2:
Entrada: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
Salida: [4,9]
Nota:
el número de apariciones de cada elemento en el resultado de salida debe ser coherente con el número de apariciones del elemento en las dos matrices.
Podemos ignorar el orden de los resultados de salida.
public static int[] intersect2(int[] nums1, int[] nums2) {
Arrays.sort(nums1);
Arrays.sort(nums2);
int i = 0;
int j = 0;
int k = 0;
while(i < nums1.length && j < nums2.length){
if(nums1[i] == nums2[j]) {
nums1[k++] = nums1[i];
i++;
j++;
} else if(nums1[i] < nums2[j]) {
i++;
} else if(nums1[i] > nums2[j]) {
j++;
}
}
return Arrays.copyOfRange(nums1,0,k);
}
Tiempo de ejecución: 2 ms
Consumo de memoria: 39,7 MB
También hay un HashMap encima de la respuesta.
mas uno
Dado un número entero no negativo representado por una matriz de números enteros no vacía, agregue uno al número.
El dígito más alto se almacena en la primera posición de la matriz y cada elemento de la matriz solo almacena un número.
Puede asumir que, además del entero 0, este número entero no comienza con cero.
Ejemplo 1:
Entrada: [1,2,3]
Salida: [1,2,4]
Explicación: La matriz de entrada representa el número 123.
Ejemplo 2:
Entrada: [4,3,2,1]
Salida: [4,3,2,2]
Explicación: La matriz de entrada representa el número 4321.
class Solution {
public int[] plusOne(int[] digits) {
if (digits == null || digits.length == 0) return null;
for(int i = digits.length - 1; i >= 0 ;i-- ) {
digits[i] ++;
digits[i] = digits[i] % 10;
if(digits[i] != 0) {
return digits;
}
}
digits = new int[digits.length + 1];
digits[0] =1;
return digits;
}
}
Al principio pensé que era complicado, y no enumeré cuidadosamente las condiciones de la pregunta, no entendí bien la pregunta, no la resolví, y luego vi la respuesta.
Mover cero
Dada una matriz de números, escriba una función para mover todos los ceros al final de la matriz mientras mantiene el orden relativo de los elementos distintos de cero.
Ejemplo:
Entrada: [0,1,0,3,12]
Salida: [1,3,12,0,0]
Explicación:
Debe operar en la matriz original y no puede copiar matrices adicionales.
Minimice el número de operaciones.
class Solution {
public void moveZeroes(int[] nums) {
int index = 0;
for(int i = 0;i < nums.length;i++){
if(nums[i] != 0) {
if(i != index) {
nums[index] = nums[i];
nums[i] = 0;
}
index ++;
}
}
}
}
Tiempo de ejecución: 0 ms
Consumo de memoria: 40,1 MB
Esta idea relativamente simple es similar a la anterior para eliminar duplicados en la matriz ordenada. No necesita preocuparse por cuántos ceros hay, simplemente inserte un número que no sea 0 hacia adelante.
Suma de dos números
No hay nada que decir al respecto.
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map = new HashMap<>();
for(int i = 0; i < nums.length;i++) {
int result = target - nums[i];
if(map.containsKey(result)) {
return new int[]{map.get(result),i};
}
map.put(nums[i],i);
}
return null;
}
}
Tiempo de ejecución: 2 ms
Consumo de memoria: 39,9 MB
Sudoku efectivo
Determina si un Sudoku 9x9 es válido. Solo necesita verificar la validez de los números ingresados de acuerdo con las siguientes reglas.
Los números del 1 al 9 solo pueden aparecer una vez por línea.
Los números del 1 al 9 solo pueden aparecer una vez en cada columna.
Los números del 1 al 9 solo pueden aparecer una vez en cada palacio de 3x3 separados por una línea sólida y gruesa.
La imagen de arriba es un Sudoku parcialmente lleno y efectivo.
Los números se han llenado en los espacios en blanco del Sudoku, y los espacios en blanco se indican con '.'.
Ejemplo 1:
Entrada:
[
["5", "3", ".", ".", "7", ".", ".", ".", "."],
["6", " . ",". "," 1 "," 9 "," 5 ",". ",". ",". "],
[". "," 9 "," 8 ",". "," . ",". ",". "," 6 ",". "],
[" 8 ",". ",". ",". "," 6 ",". ",". "," . "," 3 "],
[" 4 ",". ",". "," 8 ",". "," 3 ",". ",". "," 1 "],
[" 7 " , ".", ".", ".", "2", ".", ".", ".", "6"],
[".", "6", ".", "." , ".", ".", "2", "8", "."],
".", ".", "5"], [".", ".", ".", ".", "8", ".", ".", "7", "9"] ] Resultado: falso Explicación: Excepto que el primer número de la primera línea se cambia de 5 a 8, los otros números en el espacio son los mismos que en el ejemplo 1. Pero debido a que hay dos 8 en la casa de 3x3 ubicada en la esquina superior izquierda, este Sudoku no es válido. Descripción:
Un Sudoku válido (parcialmente llenado) no necesariamente tiene solución.
Solo necesita verificar la validez de los números ingresados de acuerdo con las reglas anteriores.
La secuencia de Sudoku dada solo contiene los números del 1 al 9 y el carácter '.'.
Un Sudoku dado siempre está en formato 9x9.
class Solution {
public boolean isValidSudoku(char[][] board) {
//三个二维数组改为boolean[][]
byte[][] rowValues = new byte[9][9];
byte[][] colValues = new byte[9][9];
byte[][] boxIndexValues = new byte[9][9];
for (int row = 0; row < 9; row++) {
for (int col = 0; col < 9; col++) {
if (board[row][col] != '.') {
int boxIndex = row / 3 * 3 + col / 3;
int value = board[row][col] - '1';//'1'是49，减去'1'正好和 0 - 8 对应
//这里我们把 == 1去掉
if (rowValues[row][value] == 1 || colValues[col][value] == 1 || boxIndexValues[boxIndex][value] == 1) {
return false;
}
//这里改为置为true
rowValues[row][value] = 1;
colValues[col][value] = 1;
boxIndexValues[boxIndex][value] = 1;
}
}
}
return true;
}
}
Tiempo de ejecución: 2 ms
Consumo de memoria: 40,2 MB
Al principio no pensé en ello. Leí las ideas de otras personas y las escribí yo mismo. De hecho, tomé las líneas horizontales y verticales y el pequeño Sudoku en una línea e hice tres matrices bidimensionales. La fila, columna y el número de Sudoku como filas de la matriz bidimensional, con números como columnas, si suma, establezca el número de posiciones en 1, cada vez que agregue para determinar si la posición correspondiente de los tres casos es 1, si es que uno es 1 no es un Sudoku válido; de lo contrario, continúe juzgando la siguiente posición.
De hecho, en la solución del problema usan un arreglo bidimensional de booleano. El booleano solo ocupa un bit, lo que equivale a 1/8 bytes. Si se usa byte, ocupa ocho bits y un byte, así lo comentamos en el comentario. un poco.
Rotar imagen
Dada una matriz bidimensional n × n representa una imagen.
Gire la imagen 90 grados en el sentido de las agujas del reloj.
Explicación:
Debe rotar la imagen en su lugar, lo que significa que debe modificar directamente la matriz bidimensional de entrada. No utilice otra matriz para rotar la imagen.
Ejemplo 1:
Dada la matriz =
[
[1,2,3],
[4,5,6],
[7,8,9]
],
rote la matriz de entrada en su lugar para hacerla:
[
[7,4, 1],
[8,5,2],
[9,6,3]
]
Ejemplo 2:
matriz dada =
[
[5, 1, 9,11],
[2, 4, 8,10],
[13, 3, 6, 7],
[15,14,12,16]
], el
original Gire la matriz de entrada para que sea:
[
[15,13, 2, 5],
[14, 3, 4, 1],
[12, 6, 8, 9],
[16, 7,10,11]
]
public static void rotate(int[][] matrix) {
int count;
for (int k = 0; k < matrix[0].length / 2; k++) {
System.out.println(k);
System.out.println("*****************");
count = 0;
for (int row = k; count < (matrix.length - 2 * k - 1) * 4; row++) {
System.out.println("-------------------");
System.out.println("row: " + row);
int curRow = row, curCol = k;
int rowww = curRow, colll = curCol;
int prev = matrix[curRow][curCol];
do {
int nextRow = curCol;
int nextCol = matrix.length - 1 - curRow;
System.out.println(curRow + "," + curCol + "-->" + nextRow + "," + nextCol);
int temp = matrix[nextRow][nextCol];
System.out.println("currentValue: " + prev + "-->" + "nextValue: " + temp);
matrix[nextRow][nextCol] = prev;
prev = temp;
curRow = nextRow;
curCol = nextCol;
System.out.println(curRow + "," + curCol);
System.out.println(rowww + "," + colll);
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
System.out.print(matrix[i][j] + ",");
if ((j + 1) % matrix.length == 0) {
System.out.println();
}
}
}
count++;
} while (!(curRow == rowww && curCol == colll));
System.out.println(count);
}
}
}
Tiempo de ejecución: 0 ms (el gráfico de tiempos no ha salido, puede ser inexacto)
Consumo de memoria: 39,7 MB
Lo cambié varias veces, y al final, se trató como pelar una cebolla ronda por ronda. Me tomó cuatro veces encontrar cada ronda de intercambio, y cada ronda volvía a la posición original y la reemplazaba. Confíe principalmente en la idea de rotar la matriz anterior. Finalmente salió.
De hecho, en el proceso de hacerlo, debido a que las columnas y filas se invirtieron, se descubrió accidentalmente que también puede referirse al tipo de matriz giratoria para voltear de una vez, y luego dividir los lados izquierdo y derecho en una sola rotación.
TODO: agregue un algoritmo para el intercambio total de ij y luego voltee cada fila
class Solution {
public void rotate(int[][] matrix){
for (int i = 0;i < matrix.length ; i++) {
for (int j = i;j < matrix.length ; j++) {
int temp = matrix[i][j];
matrix[i][j] = matrix[j][i];
matrix[j][i] = temp;
}
}
for (int i = 0;i < matrix.length ; i++) {
for (int j = 0;j < matrix.length / 2 ; j++) {
int temp = matrix[i][matrix.length - 1 - j];
matrix[i][matrix.length - 1 - j] = matrix[i][j];
matrix[i][j] = temp;
}
}
}
}
Tiempo de ejecución: 0 ms
Consumo de memoria: 39,7 MB