Пройти по любому разрешенному пути игрового поля от верхнего левого угла до правого нижнего

int main()
{
    freopen("input.txt", "rt", stdin);
    freopen("output.txt", "wt", stdout);
    
    int  n, m;
    scanf("%d %d", &n, &m);
    int** a = new int*[n];
    int** l = new int*[n];
    for (int i = 0; i < n; i++) {
        l[i] = new int[m];
        a[i] = new int[m];
        for (int j = 0; j < m; j++) {
            scanf("%d", &a[i][j]);
            l[i][j] = 0;
        }
    }
 
    l[0][0] = 1;
 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int pos = a[i][j];
 
            if (j+pos < m)
                l[i][j+pos] = l[i][j] + l[i][j+pos];
            if (i+pos < n)
                l[i+pos][j] = l[i][j] + l[i+pos][j];
        }
    }
    printf("%d", l[n-1][m-1]);
    return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////
//Игровое поле N x M заполняется целыми числами, одно неотрицательное целое число в каждой клетке. 
//Цель игры состоит в том, чтобы пройти по любому разрешенному пути от верхнего левого угла 
//до правого нижнего. Целое число в каждой клетке указывает, какой длины шаг должен быть 
//из текущей клетки. Все шаги могут быть или направо или вниз. Если в результате какого-либо 
//шага игрок покидает пределы поля, такой шаг запрещается.
//Требуется написать программу, которая определит число различных вариантов путей от верхнего 
//левого угла до правого нижнего.
//
//ВХОДНЫЕ ДАННЫЕ
//
//Входной файл INPUT.TXT содержит в первой строке размеры поля N (1 ≤ N ≤ 70) и M (1 ≤ M ≤ 70). 
//В последующих N строках входного файла, каждая из которых описывает отдельную строку игрового 
//поля, записаны через пробел по M целых чисел – длины шагов из клеток данной строки.
//
//ВЫХОДНЫЕ ДАННЫЕ
//
//Выходной файл OUTPUT.TXT должен содержать одно число - число различных вариантов путей 
//от верхнего левого угла до правого нижнего. Для каждого поля будет менее чем 231 различных путей.
/////////////////////////////////////////////////////////////////////////////////////////
#include <fstream>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
const   int     ROWS_TOTAL_MAX  =   70;
const   int     COLS_TOTAL_MAX  =   ROWS_TOTAL_MAX;
/////////////////////////////////////////////////////////////////////////////////////////
int     field               [ ROWS_TOTAL_MAX ][ COLS_TOTAL_MAX ]   =   {0};
int     variants_counter    [ ROWS_TOTAL_MAX ][ COLS_TOTAL_MAX ]   =   {0};
/////////////////////////////////////////////////////////////////////////////////////////
bool    may_go_to_right
    (
        int     steps_count,
        int     cols_total,
        int     col
    )
{
    return  col + steps_count < cols_total;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    may_go_to_down
    (
        int     steps_count,
        int     rows_total,
        int     row
    )
{
    return  row + steps_count < rows_total;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     get_variants_count
    (
        int     rows_total,
        int     cols_total
    )
{
    for( int  i = 0; i < rows_total; ++i )
    {
        for( int  j = 0; j < cols_total; ++j )
        {
            int     variants_count  =       i == 0
                                        &&  j == 0
                                            ?   1
                                            :   variants_counter[i][j];
 
            int     steps_count     =   field[i][j];
 
            if  (
                        steps_count     ==  0
                    ||  variants_count  ==  0
                )
            {
                continue;
            }
 
            if  (
                    may_go_to_right
                        (
                            steps_count,
                            cols_total,
                            j
                        )
                )
            {
                variants_counter[i][ j + steps_count ]  +=  variants_count;
            }
 
            if  (
                    may_go_to_down
                        (
                            steps_count,
                            rows_total,
                            i
                        )
                )
            {
                variants_counter[ i + steps_count ][j]  +=  variants_count;
            }
        }//for
    }//for
 
    return  variants_counter[ rows_total - 1 ][ cols_total - 1 ];
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::ifstream   ifile("INPUT.TXT");
    int     rows_total  =   0;
    ifile   >>  rows_total;
 
    int     cols_total  =   0;
    ifile   >>  cols_total;
 
    for( int  i = 0; i < rows_total; ++i )
    {
        for( int  j = 0; j < cols_total; ++j )
        {
            ifile   >>  field[i][j];
        }//for
    }//for
 
    std::ofstream   ofile( "OUTPUT.TXT" );
 
    ofile   <<  get_variants_count
                    (
                        rows_total,
                        cols_total
                    );
}