Ввод матрицы вручную

      {srand(time(0));
                
                cout<<" Labirint  "<<endl;
                for (int i=0; i<N; i++)
                        for (int j=0;j<M;j++)
                                Matr[i][j] = rand()%2;}

#include <iostream.h>
#include <iomanip.h>
#define    max_(a, b)  ((a)>(b)?(a):(b))
#define    min_(a, b)  ((a)<(b)?(a):(b))
const int  N =    8,         // число строк
           M =    8;         // и столбцов в матрице
const int  x =  1;         // численное значение клетки-"препятствия"
const int  E =    1,         // конечная
           S =   -1;         // и начальная точки
// исходная матрица: пустые клетки - нули, "препятствия" - x
// Конечная точка - E (coord: rowE,colE), исходная - S (rowS,colS)
int  Matr[N][M] = { 
    { x,  0,  0,  0,  x,  0,  E,  x },
    { 0,  0,  x,  0,  x,  0,  0,  0 },
    { 0,  x,  x,  0,  0,  0,  x,  0 },
    { 0,  0,  0,  x,  x,  x,  0,  0 },
    { 0,  0,  0,  0,  0,  0,  0,  0 },
    { 0,  x,  0,  x,  0,  x,  0,  0 },
    { 0,  0,  x,  0,  0,  0,  x,  0 },
    { x,  0,  S,  x,  0,  0,  0,  0 }
};
int    rowS  = 7,              // координаты начальной
       colS  = 2,    
       rowE  = 0,              // и конечной точки
       colE  = 6;
void   OutMatr();                                                 
void   OutWay(int matr[][M], int rS, int cS);
int    main()
{
          // копия исходной матрицы    
    int   Matrix[N][M];          
    int   i, j;
    for(i = 0; i < N; i++)
        for(j = 0; j < M; j++)
            Matrix[i][j] = Matr[i][j];
    int   n,
          Finish    = false,
          // координаты начала пути (если < 0 - пути нет)
          rS        = -1,      
          cS        = -1;
    
          // смещение
    int   offset[8] = { -1,0, 1,0, 0,-1, 0,1 };
    
          // координаты прямоугольника для поиска клеток со значением n
    int   startRow  = rowE,    
          endRow    = rowE,        
          startCol  = colE,
          endCol    = colE;
    // вывод исходного состояния матрицы
    OutMatr();                 
    // Цикл поиска клеток со значением n и заполнения соседних пустых (0) клеток
    // значением n + 1. Цикл завершается, когда нечего уже заполнять или достигнута
    // стартовая точка (со значением S)
    for(n = E; !Finish; n++)
    {
        Finish = true;
        for(i = startRow; i <= endRow; i++)
        {
            for(j = startCol; j <= endCol; j++)
            {
                if(Matrix[i][j] == n)
                {                      
                    for(int k = 0; k < 8; k += 2)
                    {
                        // проверяем значение клеток слева, справа, сверху и снизу
                        if( i + offset[k]     >= 0  && 
                            i + offset[k]     <  N  && 
                            j + offset[k + 1] >= 0  &&
                            j + offset[k + 1] <  M )
                        {
                            // и, если клетка существует и не занята (0), 
                            if(Matrix[i + offset[k]][j + offset[k + 1]] == 0)
                            {
                                // заносим n + 1
                                Matrix[i + offset[k]][j + offset[k + 1]] = n + 1;
                                Finish = false;
                            }
                            // если достигнута начальная точка (S) - запоминаем    координаты
                            // текущей точки(i, j), как начала пути(rS, cS)
                            else if(Matrix[i + offset[k]][j + offset[k + 1]] == S)
                            {
                                rS = i;
                                cS = j;
                                
                                // и выходим из всех циклов
                                goto Finish;
                            }
                        }
                    }  
                }
            }  
        }
        
        startRow   =   max_(0    , startRow - 1);
        endRow     =   min_(N - 1, endRow   + 1);
        startCol   =   max_(0    , startCol - 1);
        endCol     =   min_(M - 1, endCol   + 1);
    }  
Finish:
    if(rS >= 0)                                    // путь найден
    {
        OutWay(Matrix, rS, cS);
        OutMatr();
    }
    else
        cout << " \n\n\nbla - bla - bla \n\n";       // путь не найден, делай что хочешь
    cout << endl;
    return 0;
}
void OutMatr()
{
    static int k = 1;
    cout << (k-- ? "Source matrix:\n" : "\n\n\nOutput of the way:\n");
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < M; j++)
            cout << setw(5) << Matr[i][j];
        cout << endl;
    }
}
// Вывод пути:
// от точки rS, cS - к ближайшей (со значением на 1 меньше),
// от нее-к следующей (на 1 меньше) и т.д.-до конечной (E)
void OutWay(int matr[][M], int rS, int cS)
{
    int   rW  = rS,
          cW  = cS;
    Matr[rW][cW] = -1;
    while(matr[rW][cW] != E)
    {
        if(rW > 0 && matr[rW - 1][cW] == matr[rW][cW] - 1)
            Matr[--rW][cW] = -1;
        else if(rW < M - 1 && matr[rW + 1][cW] == matr[rW][cW] - 1)
            Matr[++rW][cW] = -1;
        else if(cW < N - 1 && matr[rW][cW + 1] == matr[rW][cW] - 1)
            Matr[rW][++cW] = -1;
        else if(cW > 0 && matr[rW][cW - 1] == matr[rW][cW] - 1)
            Matr[rW][--cW] = -1;
    }
}

for (int i = 0; i < N; i++)
    for (int  j = 0; j < M; j++)
        cin>>Matr[i][j];

#include <iostream.h>
#include <iomanip.h>
#define    max_(a, b)  ((a)>(b)?(a):(b))
#define    min_(a, b)  ((a)<(b)?(a):(b))
const int  N =    8,         // число строк
           M =    8;         // и столбцов в матрице
const int  x =  1;         // численное значение клетки-"препятствия"
const int  E =    1,         // конечная
           S =   -1;         // и начальная точки
// исходная матрица: пустые клетки - нули, "препятствия" - x
// Конечная точка - E (coord: rowE,colE), исходная - S (rowS,colS)
int  Matr[N][M];
int    rowS,              // координаты начальной
       colS,    
       rowE,              // и конечной точки
       colE;
void   OutMatr();                                                 
void   OutWay(int matr[][M], int rS, int cS);
int    main()
{
                srand(time(0));
                
                cout<<" Labirint  "<<endl;
                for (int i=0; i<N; i++)
                        for (int j=0;j<M;j++)
                                Matr[i][j] = rand()%2;
 
                cout << "Введите rowS: ";
                cin >> rowS;
                cout << "Введите colS: ";
                cin >> colS;
                cout << "Введите rowE: ";
                cin >> rowE;
                cout << "Введите colE: ";
                cin >> colE;
          // копия исходной матрицы    
    int   Matrix[N][M];          
    int   i, j;
    for(i = 0; i < N; i++)
        for(j = 0; j < M; j++)
            Matrix[i][j] = Matr[i][j];
// и продолжение твоего кода.................................

#include <iostream>
#include <iomanip>
 
using namespace std;
 
#define MAX(a, b) (a > b ? a : b)
#define MIN(a, b) (a < b ? a : b)
 
const int N = 8,    // число строк и
          M = 8;    // столбцов в матрице
 
int Matr[N][M];     // исходная матрица
int rowS, colS,     // координаты начальной и
    rowE, colE;     // конечной точек
       
void OutMatr(int Matrix[N][M]);                                                 
 
void main()
{
    int Matrix[N][M] = {{0}};   // матрица с прохождением пути
 
    setlocale(LC_ALL, "Russian");
    srand(time(0));
 
    cout << "\t--- Лабиринт ---" << endl;
 
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++)
            Matr[i][j] = rand() % 2;
 
    OutMatr(Matr);  // вывод исходной матрицы
    
    cout << "Введите координаты начальной и конечной точек:" << endl
         << "Начальная точка расположена" << endl
         << "В строке №";  cin >> rowS;
    cout << "В столбце №";    cin >> colS;
    cout << "Конечная точка расположена" << endl
         << "В строке №";  cin >> rowE;
    cout << "В столбце №";    cin >> colE;
    
    int n = 2;  // пройденное расстояние
    int offset[8] = {-1, 0, 1, 0, 0, -1, 0, 1}; // смещение относительно клетки
    bool endSearch;
    int startRow = rowS,    // координаты прямоугольника для поиска клеток со значением n
        endRow   = rowS,
        startCol = colS,
        endCol   = colS;
 
    Matr[rowS][colS] = n;
    if (rowS == rowE && colS == colE) // Если начальная является конечной точкой
        goto Finish;
    do {        
        endSearch = false;
        for (int i = startRow; i <= endRow; i++)
            for (int j = startCol; j <= endCol; j++)
                if (Matr[i][j] == n)
                    for (int k = 0; k < 8; k += 2)
                        // если найдена конечная клетка
                        if (i + offset[k] == rowE && j + offset[k + 1] == colE) {
                            Matr[i + offset[k]][j + offset[k + 1]] = ++n;
                            goto Finish;
                        } else
                            // проверка что клетка не вышла за границы матрицы
                            // и что она пуста, т.е. равна 0
                            if (i + offset[k]     >= 0 && i + offset[k]     <  N &&
                                j + offset[k + 1] >= 0 && j + offset[k + 1] <  M &&
                                Matr[i + offset[k]][j + offset[k + 1]] == 0) {
                                    Matr[i + offset[k]][j + offset[k + 1]] = n + 1;
                                    endSearch = true;
                            }
        n++;
        startRow = MAX(0    , startRow - 1);
        endRow   = MIN(N - 1, endRow   + 1);
        startCol = MAX(0    , startCol - 1);
        endCol   = MIN(M - 1, endCol   + 1);
    } while (endSearch);
Finish:
    if (Matr[rowE][colE] != n)
        cout << "Путь не найден" << endl;
    else {
        Matrix[rowE][colE] = --n;
        for (int i = n; i > 1; i--)
            for (int k = 0; k < 8; k += 2)
                if (Matr[rowE + offset[k]][colE + offset[k + 1]] == n) {
                    Matrix[rowE + offset[k]][colE + offset[k + 1]] = --n;
                    rowE += offset[k];
                    colE += offset[k + 1];
                    break;
                }
        OutMatr(Matrix);
    }
    system("pause");
}
 
void OutMatr(int Matr[N][M])
{
    static int k = 1;
    cout << (k-- ? "Исходная матрица:\n" : "\nВывод путь:\n");
    for(int i = 0; i < N; i++) {
        for(int j = 0; j < M; j++)
            cout << setw(3) << Matr[i][j];
        cout << endl;
    }
}

#include <clocale>;
#include <cstdlib>;

#include <ctime>

#include<iostream>
#include <time.h>
#include<cmath>
using namespace std;
int main()
{
        setlocale(LC_ALL,".1251");
        srand(time(0));
              //создание динамического массива
        int N;
        cout<<"Vvedite razmer matricy(N*N)(N<=20)"<<endl;
        cin>>N;
        while((N<1)||(N>20))
                {cout<<" Razmer zadan neverno, vvedite zanovo "<<endl;
                cin>>N;}
        int **mas,elem;                 
        mas = new int *[N];         
        for (int i=0; i<N; i++)     
                 mas[i] = new int [N]; 
        int vybor;
        cout<<" Dlja zapolnenija labirinta sluchajno vvedite 1 "<<endl;
        cout<<"  Dlja zapolnenija labirinta vruchnuju, vvedite 2"<<endl;
        cin>>vybor;
        switch (vybor)
        {
        case 1:
                {srand(time(0));
                
                cout<<" Labirint  "<<endl;
                for (int i=0; i<N; i++)
                        for (int j=0;j<N;j++)
                                mas[i][j] = rand()%2;}
                break;
        case 2:
                {for(int i=0;i<N;i++)
                        for(int j=0;j<N;j++)
                                {cout<< "Vvedite jelement [ "<<i+1<<" ][ "<<j+1<<" ] (0-prohod,1-stena)"<<endl;
                                cin>>elem;
        while((elem!=0)&&(elem!=1))
                {cout<<" Nevernyj simvol. Vvedite 0 dlja prohoda, 1 dlja steny"<<endl;
                cin>>elem;}
        mas[i][j]=elem;}}break;
        default: cout<<"Nepravil'nyj vvod.Programma budet zavershena"<<endl;
        return 0;}      
        for ( i=0;i<N;i++)
                {for(int k=0;k<N;k++)
                        printf( "%3d",mas[i][k]);                       
                cout<<endl;}
         int k,l;
        cout<<" Vvedite koordinaty nachal'noj komnaty"<<endl;
        cin>>k>>l;
        while((k<0)||(l<0)||(k>=N)||(l>=N)||(mas[k][l]==1))
        {cout<<"Koordinaty zanjaty stenoj ili nahodjatsja vne labirinta. Vvedite koordinaty pravil'no "<<endl;
        cin>>k>>l;}     
//поиск пути
 
        mas[k][l]=-1;   
        for( int num=-1;num+N*N>0;num--)
                for(int i=1;i<N-1;i++)
                        for (int j=1;j<N-1;j++)
        if(mas[i][j]==num)
                        {{if(mas[i+1][j]==0)
                                mas[i+1][j]=num-1;}
                        {if(mas[i-1][j]==0)
                                mas[i-1][j]=num-1;}
                        {if(mas[i][j+1]==0)
                                mas[i][j+1]=num-1;}
                        {if(mas[i][j-1]==0)
                                mas[i][j-1]=num-1;}
                        }
                //нахождение максимума на границе
        int max=-N*N,mi=-1,mj=-1;
        for (  i=0;i<N;i++)
                {if((mas[i][0]>max)&&(mas[i][0]<0))
                        {max=mas[i][0];
                        mi=i;
                        mj=0;}
                if((mas[i][N-1]>max)&&(mas[i][N-1]<0))
                        {max=mas[i][N-1];
                        mi=i;
                        mj=N-1;}}
        for(int j=0;j<N;j++)
                {if ((mas[0][j]>max)&&(mas[0][j]<0))
                        {max=mas [0][j];
                        mi=0;
                        mj=j;}
                if ((mas[N-1][j]>max)&&(mas[N-1][j]<0))
                        {max=mas[N-1][j];
                        mi=N-1;
                        mj=j;}}
        //нахождение пути
 
        if(max==-N*N)
                cout<<"Prohoda net "<<endl;
        else 
        { cout<<"Iskomyj put"<<endl;
        for(int a=max-1;a<0;a++)
        {{if (mas[mi-1][mj]==a)
                mi=mi-1;}
        { if (mas[mi+1][mj]==a)
                mi++;}
        {if (mas[mi][mj-1]==a)
                mj--;}
        {if (mas[mi][mj+1]==a)
                mj++;}
        cout<<"[ "<<mi<<" ][ "<<mj<<" ]"<<endl;}}       
        return 0;
}

OutMatr(Matr);