Programa C++ para espejo de array en diagonal

Dada una array bidimensional de orden N x N, imprima una array que sea el espejo del árbol dado a través de la diagonal. Necesitamos imprimir el resultado de una manera: intercambiar los valores del triángulo sobre la diagonal con los valores del triángulo debajo como un intercambio de imagen especular. Imprima la array 2-D obtenida en un diseño de array.

Ejemplos:  

Input : int mat[][] = {{1 2 4 }
                       {5 9 0}
                       { 3 1 7}}
Output :  1 5 3 
          2 9 1
          4 0 7

Input : mat[][] = {{1  2  3  4 }
                   {5  6  7  8 }
                   {9  10 11 12}
                   {13 14 15 16} }
Output : 1 5 9 13 
         2 6 10 14  
         3 7 11 15 
         4 8 12 16 

Una solución simple a este problema implica espacio extra. Recorremos todas las diagonales derechas (de derecha a izquierda) una a una. Durante el recorrido de la diagonal, primero empujamos todos los elementos hacia la pila y luego la recorremos nuevamente y reemplazamos cada elemento de la diagonal con el elemento de la pila. 

A continuación se muestra la implementación de la idea anterior. 

// Simple CPP program to find mirror of
// matrix across diagonal.
#include <bits/stdc++.h>
using namespace std;
  
const int MAX = 100;
  
void imageSwap(int mat[][MAX], int n)
{
    // for diagonal which start from at 
    // first row of matrix
    int row = 0;
  
    // traverse all top right diagonal
    for (int j = 0; j < n; j++) {
  
        // here we use stack for reversing
        // the element of diagonal
        stack<int> s;
        int i = row, k = j;
        while (i < n && k >= 0) 
            s.push(mat[i++][k--]);
          
        // push all element back to matrix 
        // in reverse order
        i = row, k = j;
        while (i < n && k >= 0) {
            mat[i++][k--] = s.top();
            s.pop();
        }
    }
  
    // do the same process for all the
    // diagonal which start from last
    // column
    int column = n - 1;
    for (int j = 1; j < n; j++) {
  
        // here we use stack for reversing 
        // the elements of diagonal
        stack<int> s;
        int i = j, k = column;
        while (i < n && k >= 0) 
            s.push(mat[i++][k--]);
          
        // push all element back to matrix 
        // in reverse order
        i = j;
        k = column;
        while (i < n && k >= 0) {
            mat[i++][k--] = s.top();
            s.pop();
        }
    }
}
  
// Utility function to print a matrix
void printMatrix(int mat[][MAX], int n)
{
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            cout << mat[i][j] << " ";
        cout << endl;
    }
}
  
// driver program to test above function
int main()
{
    int mat[][MAX] = { { 1, 2, 3, 4 },
                     { 5, 6, 7, 8 },
                     { 9, 10, 11, 12 },
                     { 13, 14, 15, 16 } };
    int n = 4;
    imageSwap(mat, n);
    printMatrix(mat, n);
    return 0;
}

Producción: 

1 5 9 13 
2 6 10 14 
3 7 11 15 
4 8 12 16

Complejidad del tiempo: O(n*n)

Una solución eficiente a este problema es que si observamos una array de salida, notamos que solo tenemos que cambiar (mat[i][j] a mat[j][i]). 
A continuación se muestra la implementación de la idea anterior. 

// Efficient CPP program to find mirror of
// matrix across diagonal.
#include <bits/stdc++.h>
using namespace std;
  
const int MAX = 100;
  
void imageSwap(int mat[][MAX], int n)
{
    // traverse a matrix and swap 
    // mat[i][j] with mat[j][i]
    for (int i = 0; i < n; i++)
        for (int j = 0; j <= i; j++) 
            mat[i][j] = mat[i][j] + mat[j][i] - 
                       (mat[j][i] = mat[i][j]);       
}
  
// Utility function to print a matrix
void printMatrix(int mat[][MAX], int n)
{
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            cout << mat[i][j] << " ";
        cout << endl;
    }
}
  
// driver program to test above function
int main()
{
    int mat[][MAX] = { { 1, 2, 3, 4 },
                     { 5, 6, 7, 8 },
                     { 9, 10, 11, 12 },
                     { 13, 14, 15, 16 } };
    int n = 4;
    imageSwap(mat, n);
    printMatrix(mat, n);
    return 0;
}

Producción: 

1 5 9 13 
2 6 10 14 
3 7 11 15 
4 8 12 16 

Complejidad del tiempo: O(n*n)
 

¡ Consulte el artículo completo sobre Espejo de array en diagonal para obtener más detalles!