Сколькими способами человек может попасть в магазин

void recur(int i,int t,int a[37][50]) {
    int p=f;
    if (i==0) {
        if (t==k) {
            f+=1;
            exit;
        }
    }
    if (t+i<=k) {
        if (a[i-1][t+1]==0) {
        recur(i-1,t+1,a);
        }
    }
        else if (a[i-1][t+1]>0) {
            f+=a[i-1][t+1];
        }
     if (t+i<=k) {
       if (a[i+1][t+1]==0) {
        recur(i+1,t+1,a);
       }
     }
       else if (a[i+1][t+1]>0) {
           f+=a[i+1][t+1];
       }
       if (p!=f) {
           a[i][t]=f-p;
       }
       else {
           a[i][t]=-1;
       }
     }

#include <iostream>
using namespace std;
void f(int i,int *ptr) {
    if (i==0) return;
    else {
        cout << "Работает" << endl;
        cout << *ptr << endl;
        f(i-1,ptr);
    }
}
int main() {
 
int *ptr = new int;
*ptr = 3;
f(6,ptr);
cout << *ptr;
delete(ptr);
}

#include <iostream>
using namespace std;
void Foo(int x)
{
   if(x == 0)
      return;
   if(x < 5)
   {
      cout << "Q";
      return Foo(x-1);
   }
   else
   {
      cout << "q";
      return Foo(x-1);
   }
   if(x < 5)
   {
      cout << "Z";
      return Foo(x-1);
   }
   else
   {
      cout << "z";
      return Foo(x-1);
   }
}
 
int main()
{
     Foo(10);
     return 0;
}

i64 get(int x, int kk) {
    if(dp[x][kk] == -1) {
        dp[x][kk] = 0;
        if(kk > 0 && kk <= k) {
            if(x >= 2)
                dp[x][kk] += get(x-1, kk-1);
            dp[x][kk] += get(x+1, kk-1);
        }
    }
    return dp[x][kk];
}
 
int main() {
...
    cout << get(0, k) << endl;
...
}

#include <stdio.h>
#include <iostream>
using namespace std;
 int a[37][50]={0};
 int n,k;
long rec(int i, int t) {
    if (i==0) {
        if (t==k) return 1;
        else return 0;
    }
    if  (t+i<=k) {
        if (a[i][t]==0) {
            a[i][t]+=rec(i-1,t+1);
            a[i][t]+=rec(i+1,t+1);
        }
    }
        return a[i][t];
    }
int main() {
  freopen("input.txt","r",stdin);
  freopen("output.txt","w",stdout);
 cin >> n >> k;
 cout << rec(n,0);
 return 0;
}

static int a[40][50];

int *arr = new long[50];
delete []arr;

void func(long[50] *point)

/////////////////////////////////////////////////////////////////////////////////////////
//МАГАЗИН
//
//На расстоянии N шагов от магазина стоит человек. Каждую минуту он выбирает, куда сделать шаг: 
//к магазину или в противоположном направлении.
//
//Требуется написать программу, которая определит, сколькими способами он может попасть в магазин, 
//пройдя ровно K шагов и оказавшись в магазине только после выполнения последнего шага.
//
//ВХОДНЫЕ ДАННЫЕ
//
//Входной файл INPUT.TXT содержит 2 числа n и k, записанные через пробел. Известно, что 1 <= N <= K <= 37.
//
//ВЫХОДНЫЕ ДАННЫЕ
//
//Выходной файл OUTPUT.TXT должен содержать одно число – количество способов попадания в магазин.
//
//Примеры
//INPUT.TXT OUTPUT.TXT
//2 4 ________________ 2
//5 5 ________________ 1
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <map>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::pair   < int,                      int         >   T_dist_and_steps_count;
typedef long long                                               T_variants;
typedef std::map    < T_dist_and_steps_count,   T_variants  >   T_variants_for_dist_and_steps_count;
/////////////////////////////////////////////////////////////////////////////////////////
T_variants  count_variants_for_distance_and_steps_count
    (
        int                                         distance,
        int                                         steps_count,
        T_variants_for_dist_and_steps_count     &   variants_for_dist_and_steps_count
    )
{
    if  (
            ( distance + steps_count ) % 2
        )
    {
        return  0;
    }
    else
    {
        auto    dist_and_steps_count    =   std::make_pair( distance, steps_count );
 
        if  (
                    variants_for_dist_and_steps_count.find  ( dist_and_steps_count )
                ==  variants_for_dist_and_steps_count.end   ()
            )
        {
                variants_for_dist_and_steps_count[ dist_and_steps_count ]
            =   distance    ==  0
                    ?   0
                    :   distance    ==  steps_count
                            ?   1
                            :       count_variants_for_distance_and_steps_count
                                        (
                                            distance        -   1,
                                            steps_count     -   1,
                                            variants_for_dist_and_steps_count
                                        )
 
                                +   count_variants_for_distance_and_steps_count
                                        (
                                            distance        +   1,
                                            steps_count     -   1,
                                            variants_for_dist_and_steps_count
                                        );
        }//if
 
        return  variants_for_dist_and_steps_count[ dist_and_steps_count ];
    }//else
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        T_variants_for_dist_and_steps_count     variants_for_dist_and_steps_count;
 
        std::cout   <<  "n = ";
        int     n   =   0;
        std::cin    >>  n;
 
        std::cout   <<  "k = ";
        int     k   =   0;
        std::cin    >>  k;
 
        std::cout   <<  count_variants_for_distance_and_steps_count
                            (
                                n,
                                k,
                                variants_for_dist_and_steps_count
                            )
 
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }//for
}