Выполнить перестановку столбцов и строк матрицы так, чтобы минимальный элемент оказался в левом верхнем углу

 #include "stdafx.h"
#include <iostream>
//#include <cstdlib>
int main()
{
    const int n = 5;
    const int m = 7;
    int i, j, mat[n][m];
    for (i = 0; i < n; ++i) {
        for (j = 0; j < m; ++j) {
            mat[i][j] = std::rand() % 10;
            
            std::cout << mat[i][j] << ' ';      
        }
          std::cout << std::endl;   
    }
    std::cout << std::endl;
    int row = 1, col = 1;
    int i1 = 0, j1 = 0;
    for (i = 0; i < n; ++i) {
        for (j = 0; j < m; ++j) {
            if (mat[i][j] < mat[i1][j1]) {
                i1 = i;
                j1 = j;
            }
        }
    }
 
    //переставить столбцы
    int dx = (j1 > col) ? -1 : 1;
    for (j = j1; j != col; j += dx) {
        for (i = 0; i < n; ++i) {
            std::swap(mat[i][j], mat[i][j + dx]);
        }
    }
 
    //переставить строки
    int dy = (i1 > row) ? -1 : 1;
    for (i = i1; i != row; i += dy) {
        for (j = 0; j < m; ++j) {
            std::swap(mat[i][j], mat[i + dy][j]);
        }
    }
 
    //вывести
    for (i = 0; i < n; ++i) {
        for (j = 0; j < m; ++j) {
            std::cout << mat[i][j] << '  ';
        }
        std::cout << std::endl;
        //cout << endl;
    }
    getchar();
    return 0;
}

#include <iostream>
#include <stdexcept>
#include <cstdlib>
#include <ctime>
 
class Matrix2D
{
public:
    Matrix2D(void) = delete;
    Matrix2D(const Matrix2D&) = delete;
    Matrix2D(const Matrix2D&&) = delete;
    Matrix2D& operator=(const Matrix2D&) = delete;
 
    struct Coord
    {
        int x;
        int y;
    };
 
    enum class RotateTo { Up, Down, Left, Right };
 
    template<typename T, typename U>
    static void Rotate(T **Matrix, const U &Rows, const U &Cols, const RotateTo &Key)
    {
        switch (Key)
        {
        case RotateTo::Up:
        {
            for (U j = 0; j < Cols; ++j)
            {
                T tmp = std::move(Matrix[0][j]);
                for (U i = 0; i < (Rows - 1); ++i)
                {
                    Matrix[i][j] = std::move(Matrix[i + 1][j]);
                }
                Matrix[Rows - 1][j] = std::move(tmp);
            }
            break;
        }
        case RotateTo::Down:
        {
            for (U j = 0; j < Cols; ++j)
            {
                T tmp = std::move(Matrix[Rows - 1][j]);
                for (U i = Rows - 1; i > 0; --i)
                {
                    Matrix[i][j] = std::move(Matrix[i - 1][j]);
                }
                Matrix[0][j] = std::move(tmp);
            }
            break;
        }
        case RotateTo::Left:
        {
            for (U i = 0; i < Rows; ++i)
            {
                T tmp = std::move(Matrix[i][0]);
                for (U j = 0; j < (Cols - 1); ++j)
                {
                    Matrix[i][j] = std::move(Matrix[i][j + 1]);
                }
                Matrix[i][Cols - 1] = std::move(tmp);
            }
            break;
        }
        case RotateTo::Right:
        {
            for (U i = 0; i < Rows; ++i)
            {
                T tmp = std::move(Matrix[i][Cols - 1]);
                for (U j = Cols - 1; j > 0; --j)
                {
                    Matrix[i][j] = std::move(Matrix[i][j - 1]);
                }
                Matrix[i][0] = std::move(tmp);
            }
            break;
        }
        default:
            throw std::invalid_argument("You can use only Up/Down/Left/Right!");
        }
    }
 
    template<typename T, typename U>
    static void Print(T **Matrix, const U &Rows, const U &Cols)
    {
        for (U i = 0; i < Rows; ++i)
        {
            for (U j = 0; j < Cols; ++j)
            {
                std::cout << Matrix[i][j] << ' ';
            }
            std::cout << std::endl;
        }
    }
 
    template<typename T, typename U>
    static void MoveElemWith(T **Matrix, const U &Rows, const U &Cols, const Coord &From, const Coord &To)
    {
        Coord resPoint{ From.x - To.x, From.y - To.y };
        while (resPoint.x || resPoint.y)
        {
            if (resPoint.x)
            {
                if (resPoint.x < 0)
                {
                    Rotate(Matrix, SIZE_ROWS, SIZE_COLS, RotateTo::Down);
                    ++resPoint.x;
                }
                else if (resPoint.x > 0)
                {
                    Rotate(Matrix, SIZE_ROWS, SIZE_COLS, RotateTo::Up);
                    --resPoint.x;
                }
            }
            if (resPoint.y)
            {
                if (resPoint.y < 0)
                {
                    Rotate(Matrix, SIZE_ROWS, SIZE_COLS, RotateTo::Right);
                    ++resPoint.y;
                }
                else if (resPoint.y > 0)
                {
                    Rotate(Matrix, SIZE_ROWS, SIZE_COLS, RotateTo::Left);
                    --resPoint.y;
                }
            }
        }
    }
};
 
const unsigned SIZE_ROWS{ 4 };
const unsigned SIZE_COLS{ 4 };
const unsigned MAX_RAND{ 10 };
const Matrix2D::Coord point{ 1,1 };
 
typedef unsigned uint;
 
int main()
{
    std::srand(uint(std::time(0)));
    Matrix2D::Coord pMinElem{ 0,0 };
    int **Matrix{ new int*[SIZE_ROWS] };
    {
        int min{ MAX_RAND };
        for (uint i{ 0 }; i < SIZE_ROWS; ++i)
        {
            Matrix[i] = new int[SIZE_COLS];
            for (uint j{ 0 }; j < SIZE_COLS; ++j)
            {
                Matrix[i][j] = rand() % MAX_RAND;
                if (min > Matrix[i][j])
                {
                    min = Matrix[i][j];
                    pMinElem = { static_cast<int>(i), static_cast<int>(j) };
                }
            }
        }
    }
 
    Matrix2D::Print(Matrix, SIZE_ROWS, SIZE_COLS);
    std::cout << std::endl;
    
    Matrix2D::MoveElemWith(Matrix, SIZE_ROWS, SIZE_COLS, pMinElem, point);
 
    Matrix2D::Print(Matrix, SIZE_ROWS, SIZE_COLS);
    std::cout << std::endl;
 
    for (uint i = 0; i < SIZE_ROWS; delete[] Matrix[i++]);
    delete[] Matrix;
}