Dada una array cuadrada mat[][] de dimensión N y un número entero K , la tarea es rotar la array 90 grados K veces sin cambiar la posición de los elementos diagonales.
Ejemplos:
Entrada: mat[][] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}, {16, 17, 18, 19, 20}, {21, 22, 23, 24, 25}}, K = 1
Salida:
1 16 11 6 5
22 7 12 9 2
23 18 13 8 3
24 17 14 19 4
21 20 15 10 25Entrada: mat[][] = {{10, 11}, {12, 13}}, K = 2
Salida:
10 11
12 13
Enfoque: El problema dado se puede resolver usando la idea discutida en este artículo y el hecho de que la array se restaura después de realizar una rotación en el sentido de las agujas del reloj 4 veces. Siga los pasos a continuación para resolver el problema dado:
- Actualice el valor de K como K % 4 .
- Iterar hasta que K sea positivo y realizar los siguientes pasos:
- Recorra la array , para i sobre el rango [0, N / 2) y j sobre el rango [0, N – i – 1) y realice los siguientes pasos:
- Si el valor de i != j y (i + j) != (N – 1) , realice los siguientes pasos:
- Almacene el valor de mat[i][j] en una variable temporal temp .
- Actualice el valor de mat[i][j] como mat[N – 1 – j][i] .
- Actualice el valor de mat[N – 1 – j][i] como mat[N – 1 -i][N – 1 – j] .
- Actualice el valor de mat[N – 1 – i][N – 1 – j] como mat[j][N – 1 – i] .
- Actualice el valor de mat[j][N – 1 – i] como temp .
- Después de completar los pasos anteriores, imprima la array actualizada obtenida.
A continuación se muestra la implementación del enfoque anterior:
Java
// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
public class GFG {
// Function to print the matrix
static void print(int mat[][])
{
// Iterate over the rows
for (int i = 0; i < mat.length; i++) {
// Iterate over the columns
for (int j = 0; j < mat[0].length; j++)
// Print the value
System.out.print(mat[i][j] + " ");
System.out.println();
}
}
// Function to perform the swapping of
// matrix elements in clockwise manner
static void performSwap(int mat[][], int i, int j)
{
int N = mat.length;
// Stores the last row
int ei = N - 1 - i;
// Stores the last column
int ej = N - 1 - j;
// Perform the swaps
int temp = mat[i][j];
mat[i][j] = mat[ej][i];
mat[ej][i] = mat[ei][ej];
mat[ei][ej] = mat[j][ei];
mat[j][ei] = temp;
}
// Function to rotate non - diagonal
// elements of the matrix K times in
// clockwise direction
static void rotate(int mat[][], int N, int K)
{
// Update K to K % 4
K = K % 4;
// Iterate until K is positive
while (K-- > 0) {
// Iterate each up to N/2-th row
for (int i = 0; i < N / 2; i++) {
// Iterate each column
// from i to N - i - 1
for (int j = i; j < N - i - 1; j++) {
// Check if the element
// at i, j is not a
// diagonal element
if (i != j && (i + j) != N - 1) {
// Perform the swapping
performSwap(mat, i, j);
}
}
}
}
// Print the matrix
print(mat);
}
// Driver Code
public static void main(String[] args)
{
int K = 5;
int mat[][] = {
{ 1, 2, 3, 4 },
{ 6, 7, 8, 9 },
{ 11, 12, 13, 14 },
{ 16, 17, 18, 19 },
};
int N = mat.length;
rotate(mat, N, K);
}
}
// This code is contributed by Kingash.
1 11 6 4 17 7 8 2 18 12 13 3 16 14 9 19
Complejidad de tiempo: O(N 3 ) ya que se usan tres bucles internos, uno while y dos bucles for
Espacio auxiliar: O(1)
¡ Consulte el artículo completo sobre Rotar todos los elementos de Matrix excepto la diagonal K veces 90 grados en el sentido de las agujas del reloj para obtener más detalles!
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA