Рекурсия с мемоизацией...треугольник

//////////////////////////////////////////////////////////////////////////////////////
//Пути в числовом треугольнике начинаются от верхнего числа. От любого числа можно 
//перейти к одному из двух соседних чисел в следующей строке. Вычислить максимальную 
//среди сумм чисел, расположенных на путях, заканчивающихся каким-нибудь числом 
//в основании треугольника, и найти один из путей с этой суммой. В следующем 
//треугольнике он образован выделенными числами:
//7
//3 8
//8 1 0
//2 7 4 4
//4 5 2 6 5
//...программа с рекурсией,... мемоизацию сюда подключить...
//////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <vector>
//////////////////////////////////////////////////////////////////////////////////////
typedef std::vector<int>  T_cols;
//////////////////////////////////////////////////////////////////////////////////////
int     sum_max = 0;
T_cols  cols_for_max;
//////////////////////////////////////////////////////////////////////////////////////
const int  TR_DIM              = 5;
const int  tr[TR_DIM][TR_DIM]  = {{7, 0, 0, 0, 0},
                                  {3, 8, 0, 0, 0},
                                  {8, 1, 0, 0, 0},
                                  {2, 7, 4, 4, 0},
                                  {4, 5, 2, 6, 5}};
//////////////////////////////////////////////////////////////////////////////////////
void  get_path
    (
        int      row      = 0,
        T_cols&  cols     = T_cols(), 
        int      sum_cur  = 0
    )
{
    if(row == 0)
    {        
        cols.push_back(0);
        sum_cur = tr[row][cols.back()];
    }
    
    if(row == TR_DIM - 1)
    {
        if(sum_cur > sum_max)
        {
            sum_max       = sum_cur;
            cols_for_max  = cols;
        }
        return;
    }
    int  row_new = row + 1;
 
    T_cols  cols_left(cols);                
    cols_left.push_back(cols.back());
    int  sum_cur_left = sum_cur + tr[row_new][cols_left.back()];
    get_path(row_new, cols_left, sum_cur_left);    
 
    T_cols  cols_right(cols);                
    cols_right.push_back(cols.back() + 1);
    int  sum_cur_right = sum_cur + tr[row_new][cols_right.back()];
    get_path(row_new, cols_right, sum_cur_right);
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    get_path();
    std::cout << "В заданном треугольнике "
              << std::endl;
    for(int i = 0; i < TR_DIM; ++i)
    {
        for(int j = 0; j <= i; ++j)
        {
            std::cout << tr[i][j]
                      << '\t';
        }
        std::cout << std::endl
                  << std::endl;
    }
    std::cout << "путь с максимальной суммой "
              << sum_max
              << " имеет индексы столбцов"
              << std::endl;
 
    std::copy(cols_for_max.begin(), cols_for_max.end(), 
              std::ostream_iterator<int>(std::cout, "\t"));
 
    std::cout << std::endl;
}

#include <stdio.h>
#include <cstdlib>
#include <iostream>
 
using namespace std;
FILE *f;
int n,Doc[100][100],F[100][100];//количество элементов в последней строке или высота треугольника
int booter[100][100];//двумерный массив треугольника
int i,x,j;//,S;//счетчики
 
void readdata() {
  f=fopen("input.txt","r");
  fscanf(f,"%d",&n);
  for(i=0;i<n;i++) {
    for(j=0;j<=i;j++) {
      fscanf(f,"%d",&booter[i][j]);
    };
  };
  fclose(f);
    for (i=0;i<n;i++)
    {
        for (j=0;j<=i;j++) printf ("%4d", booter[i][j]);
    printf("\n");
    }
    printf("\n------------------------\n");
};
 
void writedata() 
    {
    f=fopen("output.txt","w");
    fprintf (f,"%d", booter[0][0]);
 
    for (i=0;i<n;i++)
    {
        for (j=0;j<=i;j++) printf ("%4d", booter[i][j]);
    printf("\n");
    }
    printf("\n------------------------\n");
   
    for (i=0;i<n;i++)
    {
        for (j=0;j<=i;j++) printf ("%4d", Doc[i][j]);
    printf("\n");
    }
//    fclose(f);
    };
 
int rec()//фунция подсчета максимальной суммы
{
  for (i=n-2;i>=0;i--) 
    for (j=0;j<=i;j++) 
    {
        booter[i][j]+=(booter[i+1][j]>booter[i+1][j+1])?booter[i+1][j]:booter[i+1][j+1];
        Doc[i][j]=(booter[i+1][j]>booter[i+1][j+1])?0:1;
    }
 
}
 
int main(int argc, char* argv[])
{
    readdata();
    for (i=0;i<n;i++)
    {
        for (j=0;j<=i;j++)
        {
            F[i][j]=booter[i][j];
            }
        }
    rec(); 
 
    writedata();
 
    cout<<endl;
    j=0;
    for (i=0;i<n;i++)
    {
            cout<<" "<<F[i][j];
            if (Doc[i][j]==1)
            j++;
        }
    cout<<endl;
    cout<<"Max sum="<<booter[0][0]<<endl;
    cout<<endl;
    system("PAUSE");
    return EXIT_SUCCESS;
}