Определить, существует ли маршрут (вариант обхода графа), удовлетворяющий заданным критериям

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    int n,m,start_i,start_j;
    cin>>n>>m;
    vector<vector<int> > g(n, vector<int> (m) );
    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++)
        {
            cin>>g[i][j]; if (g[i][j]==1) {start_i=i;start_j=j;}
        }
    int k_nm=n*m;
    int start_g=g[start_i][start_j];
    int counter=1;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            int element4=0;
            if (i>0)   if (start_g+1==g[i-1][j]) {element4++;}
            if (i<n-1) if (start_g+1==g[i+1][j]) {element4++;}
            if (j>0)   if (start_g+1==g[i][j-1]) {element4++;}
            if (j<m-1) if (start_g+1==g[i][j+1]) {element4++;}
            if (element4>1) {cout<<"NO"<<endl; break;}
            if (element4==0)
                if (counter==k_nm) {cout<<"YES"<<endl; break;}
                    else {cout<<"NO"<<endl; break;}
            start_g=g[i][j];
            counter++;
        }
    }
    return 0;
}

#include <iostream>
#include <iomanip>
 
using namespace std;
 
struct Coord {
    int m_col, m_row;
    Coord() : m_col(0), m_row(0) {}
    Coord(int x, int y) : m_col(x), m_row(y) {}
 
    void set(int x, int y) {
        m_col = x; m_row = y;
    }
 
    bool isGood(const Coord &border) {
        return m_col >= 0 && m_row >= 0 && m_col < border.m_col && m_row < border.m_row;
    }
 
    Coord & operator+=(const Coord &rh) {
        m_col += rh.m_col;
        m_row += rh.m_row;
        return *this;
    }
};
 
bool find_next_location(int **locations, const Coord &border, Coord &loc) {
    static const int dirs = 4;          // количество направлений
    static const Coord dif[dirs] = {    // массив изменений координат по направлениям
        {  1,  0 },                     // движение вправо
        {  0,  1 },                     // движение вниз
        { -1,  0 },                     // движение влево
        {  0, -1 }                      // движение вверх
    };
    const int next_time = locations[loc.m_row][loc.m_col] + 1;  // следующее время
    Coord temp, next;
    int cnt = 0;                        // счётчик подходящих соседних клеток
 
    // проверка по всем направлениям
    for (int i = 0; i < dirs; ++i) {
        temp = loc;                     // текущее положение
        temp += dif[i];                 // сдвигаемся на соседнюю клетку
        if (temp.isGood(border)) {      // координаты не выходят за пределы таблицы?
            if (locations[temp.m_row][temp.m_col] == next_time) {
                                        // время совпадает с ожидаемым
                ++cnt;
                next = temp;            // запоминаем предполагаемое следующее положение туриста
            }
        }
    }
 
    if (cnt == 1) {                     // для следующего положения туриста есть только один вариант
        loc = next;                     // возвращаем найденное положение
        return true;                    // сигнализируем об успехе
    }
    return false;
}
 
int main() {
 
    int n, m;
    cin >> n >> m;
 
    // создать двухмерный динамический массив
    int **locations = new int *[n];
    for (int i = 0; i < n; ++i)
        locations[i] = new int[m];
 
    const Coord border(m, n);           // границы таблицы
    bool finish = true;                 // флаг, что путешествие закончено
    Coord loc;                          // текущее положение туриста
 
    // заполнить массив данными и вычислить координаты начала маршрута
    int time;
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j) {
            cin >> time;
            locations[i][j] = time;
            if (time == 1) {
                loc.set(j, i);          // нашли начало маршрута
                finish = false;         // можно начинать путешествие
            }
        }
 
    int route_counter = 1;              // счётчик маршрута
    const int route_len = n * m;        // длина маршрута
 
    while (!finish) {
        finish = !find_next_location(locations, border, loc);
        if (!finish)
            ++route_counter;
    }
 
    cout << (route_counter == route_len ? "YES" : "NO") << endl;
 
    // удалить двухмерный динамический массив
    for (int i = 0; i < n; ++i)
        delete[] locations[i];
    delete[] locations;
 
    return 0;
}

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
 
using namespace std;
 
struct Location {
    int m_time;
    int m_col, m_row;
    Location(int x, int y, int time) : m_time(time), m_col(x), m_row(y) {}
};
 
typedef vector<Location> Locations;
 
int main() {
 
    Locations site;
    int n, m;
    int time;
 
    cin >> n >> m;
    for (int y = 0; y < n; ++y) {
        for (int x = 0; x < m; ++x) {
            cin >> time;
            site.emplace_back(x, y, time);
        }
    }
 
    sort(site.begin(), site.end(), [](const Location &lh, const Location &rh) { return lh.m_time < rh.m_time; });
 
    bool result = true;
    Location &prev = site[0];
    for (size_t i = 1; i < site.size(); ++i) {
        Location &loc = site[i];
        if (loc.m_time != prev.m_time + 1) {
            result = false;
            break;
        }
        if (!((1 == abs(prev.m_col - loc.m_col) && prev.m_row == loc.m_row)
            || (1 == abs(prev.m_row - loc.m_row) && prev.m_col == loc.m_col))) {
            result = false;
            break;
        }
        prev = loc;
    }
 
    cout << (result ? "YES" : "NO") << endl;
 
    return 0;
}

#include <algorithm>
#include <iostream>
#include <vector>
 
using namespace std;
 
int main(void)
{
    int n, m;
    cin >> n >> m;
    vector<pair<int,int>> map(n * m);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            int t;
            cin >> t;
            map[t - 1] = make_pair(i, j);
        }
    }
    cout << (mismatch(map.cbegin() + 1, map.cend(), map.cbegin(),
        [](auto a, auto b) {
            int dx = abs(a.first - b.first);
            int dy = abs(a.second - b.second);
            return dx == 0 && dy == 1 || dx == 1 && dy == 0;
        }).first == map.cend() ? "YES" : "NO") << endl;
    return 0;
}

#include <algorithm>
#include <iostream>
#include <vector>
 
using namespace std;
 
int main(void)
{
    int n, m;
    cin >> n >> m;
    vector<pair<int,int>> map(n * m);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            int t;
            cin >> t;
            map[t - 1] = make_pair(i, j);
        }
    }
    cout << (mismatch(map.cbegin() + 1, map.cend(), map.cbegin(),
        [](pair<int,int> a, pair<int,int> b) {
            int dx = abs(a.first - b.first);
            int dy = abs(a.second - b.second);
            return dx == 0 && dy == 1 || dx == 1 && dy == 0;
        }).first == map.cend() ? "YES" : "NO") << endl;
    return 0;
}