Клетчатая доска - Определить количество способов добраться до последней клетки N-M

#include <iostream>
 
using namespace std;
 
bool barrier(int i, int j, int **Arr, int n) { // Функция проверяет преграда ячейка или нет
    for (int k = 0; k < n; k++) {
        if (i == Arr[k][0]-1 && j == Arr[k][1]-1) {
            return true;
        }
    }
    return false;
}
 
int main() {
    int n,m,k;
    int row = 0;
    int col = 0;
    cin >> n >> m; // Размер клеточной доски
        
    unsigned long **possible = new unsigned long* [n]; 
    for (int i = 0; i < n; i++)
        possible[i] = new unsigned long [m]; 
 
    cin >> k; // Количество преград
 
    int **Arr = new int* [2]; 
    for (int i = 0; i < k; i++)
        Arr[i] = new int [2]; 
 
    if (k > 0) {
        for (int i = 0; i < k; i++) { // Заносим координаты преград
            for (int j = 0; j < 2; j++) {
                cin >> Arr[i][j];
            }
        }
    }
    
    possible[row][col] = 1;
    bool start = false;
 
    for (int i = 0; i < n; i++) { // Считаем для каждой ячейки - сколькими способами можно до нее добраться
        for (int j = 0; j < m; j++) {
            if (barrier(i, j, Arr, k)) { // Если ячейка преграда, делаем кол-во способов добраться до нее 0, чтобы дальнейшие ячейки не могли иметь путь через нее
                possible[i][j] = 0;
                continue;
            }
            if (start) {
                if (i == 0) {
                    possible[i][j] = possible[i][j-1]; // Если ячейки из верхней строчки, то можем попасть в нее только с левой ячейки, получаем из нее коли-чество способов добраться
                    continue;
                }
                if (j == 0) { // Если ячейка из левого столбика, то можем попасть в нее только сверху, получаем из нее коли-чество способов добраться
                    possible[i][j] = possible[i-1][j];
                    continue;
                }
                possible[i][j] = possible[i][j-1] + possible[i-1][j]; // В иных случаях прибавляем кол-во способов добраться из верхней ячейки и левой
            }
            else {
                start = true;
            }
        }
    }
 
    cout << possible[n-1][m-1]%1000000007; // Выводим остаток от деления на 1000000007
    
    return 0;
}

if(k<=0)return 0;
int **Arr = new int* [k];
 for (int i = 0; i < k; i++) Arr[i] = new int [2];

/////////////////////////////////////////////////////////////////////////////////////////
//Задача такая: дана клетчатая доска NxM (1 <= N,M <= 1000), мы находимся в самой 
//первой клетке 1-1. Нужно определить количество способов добраться до последней клетки N-M. 
//Можно двигаться только вправо и вниз, также на доске существуют препятствия с известными 
//координатами, через них пройти нельзя. Входные данные (Пример):
//3 3 - размеры доски
//1 - кол-во преград
//2 2 - координаты преграды
//
//Так как в конце может получиться большое число, требуют в ответе написать остаток 
//от деления на 1 000 000 007.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <iterator>
#include <set>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::pair       < int,  int >   T_cell;
typedef std::set        < T_cell    >   T_cells;
typedef std::complex    < int       >   T_int_comlex;
typedef long                            T_paths_count;
typedef T_paths_count*                  T_row;
typedef T_row*                          T_matr;
/////////////////////////////////////////////////////////////////////////////////////////
T_paths_count   const   OBSTACLE_VAL        =   -1;
T_paths_count   const   MODULUS             =   1000000007;
T_paths_count   const   HALF_OF_MODULUS     =   MODULUS / 2;
/////////////////////////////////////////////////////////////////////////////////////////
T_cells     get_rand_obstacles
    (
        int     n,
        int     m
    )
{
    size_t      obstacles_count     =   rand() % ( n * m / 3 + 1 );
    T_cells     res_cells;
 
    while( res_cells.size() < obstacles_count )
    {
        res_cells.insert
            (
                T_cell
                    (
                        rand() % n,
                        rand() % m
                    )
            );
    }//while
 
    return  res_cells;
}
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_insert_obstacle_in_board
{
    //-----------------------------------------------------------------------------------
    T_matr  &   board_;
    //-----------------------------------------------------------------------------------
    T_insert_obstacle_in_board( T_matr  &   board )
        :
        board_( board )
    {}
    //-----------------------------------------------------------------------------------
    void    operator() ( T_cell     const   &   cell )
    {
        board_
            [ cell.first    ]
            [ cell.second   ]   =   OBSTACLE_VAL;
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
void    fill_board_of_obstacles
    (
        T_matr              &   board,
        T_cells     const   &   obstacles
    )
{
    std::for_each
        (
            obstacles.begin             (),
            obstacles.end               (),
            T_insert_obstacle_in_board  ( board )
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
inline  void    normalize( T_paths_count  &   val )
{
    if( val     >=  HALF_OF_MODULUS )
    {
        val     %=  MODULUS;
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
T_paths_count   get_paths_count_congruent_modulo_in_board_with_sizes
    (
        int         modulus,
        T_matr  &   board,
        int         n,
        int         m
    )
{
    if  (
                board[0][0]             ==  OBSTACLE_VAL
            ||  board[n - 1][m - 1]     ==  OBSTACLE_VAL
        )
    {
        return  0;
    }
 
    for( int  i = 0; i < n; ++i )
    {
        for( int  j = 0; j < m; ++j )
        {
            T_paths_count     &   cur_cell_val_ref    =   board[i][j];
 
            if  (
                    cur_cell_val_ref    !=  OBSTACLE_VAL
                )
            {
                cur_cell_val_ref    =   0;
 
                if  (
                            i   ==  0
                        &&  j   ==  0
                    )
                {
                    cur_cell_val_ref    =   1;
                }
 
                if  (
                            j   >   0
                        &&  board[i][j - 1]     !=  OBSTACLE_VAL
                    )
                {
                    cur_cell_val_ref    +=  board[i][j - 1];
                    normalize( cur_cell_val_ref );
                }//if
 
                if  (
                            i   >   0
                        &&  board[i - 1][j]     !=  OBSTACLE_VAL
                    )
                {
                    cur_cell_val_ref    +=  board[i - 1][j];
                    normalize( cur_cell_val_ref );
                }//if
            }//if
        }//for
    }//for
 
    return  board[n - 1][m - 1];
}
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_print_cell
{
    void    operator()  ( T_cell    const   &   cell )
    {
        std::cout   <<  T_int_comlex
                            (
                                cell.first,
                                cell.second
                            )
 
                    <<  '\t';
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  "Введите размеры доски:"
                    <<  std::endl
                    <<  "\tn = ";
 
        int     n   =   0;
        std::cin    >>  n;
        std::cout   <<  "\tm = ";
        int     m   =   0;
        std::cin    >>  m;
 
        T_matr  board   =   new     T_row[n];
 
        for( int  i = 0; i < n; ++i )
        {
            board[i]    =   new     T_paths_count[m]; 
        }
 
        T_cells     obstacles   =   get_rand_obstacles( n, m );
 
        fill_board_of_obstacles
            (
                board,
                obstacles
            );
 
        T_paths_count   paths_count_congruent_modulo
            =   get_paths_count_congruent_modulo_in_board_with_sizes
                    (
                        MODULUS,
                        board,
                        n,
                        m
                    );
 
        /*
        std::cout   <<  "Координаты препятствий:"
                    <<  std::endl;
 
        std::for_each
            (
                obstacles.begin     (),
                obstacles.end       (),
                T_print_cell        ()
            );
        */
 
        std::cout   <<  std::endl
                    <<  "Число препятствий\t: "
                    <<  obstacles.size()
                    <<  std::endl
                    <<  "Число путей по модулю\t: "
                    <<  paths_count_congruent_modulo
                    <<  std::endl;
    }
}