Распределение ресурсов для 2х производств

#include <fstream>
#include <cmath>
#include <iostream>

#define temp_count 251

using namespace std;

ofstream inverse("inverse.txt"); //таблицы обратного планирования
ofstream direct("direct.txt"); //таблица прямого планирования и максимальная прибыль

int *x = new int[temp_count];
double  *f = new double[temp_count],
        *g = new double[temp_count],
        *phi = new double[temp_count],
        *psi = new double[temp_count];
double table[5][temp_count][3];
double optimize[4][8];

int k_max, step;

void reverse(int month){
    cout<<"Обратное планирование для "<<month<<" месяца...\n";
    double max = -1;
    int var_x = 0;
    int k_to = (month==1)?0:k_max;
    double temp_max;

    for (int k = 0; k <= k_to; k++){
        int k_mul = (month==1)?k_max:k;
        for (; var_x <= k_mul; var_x++){
            if(month<4){
                double tmp = phi[var_x] + psi[k_mul - var_x];
                int lower_level = (int)floor(tmp); //нижняя граница для числа
                int upper_level = (int)ceil(tmp); //верхняя граница для числа
                while ( lower_level % step ) lower_level--;
                while ( upper_level % step ) upper_level++;
                lower_level /= step; //чтобы не вылетел за границы, индекс в массиве в 4 раза меньше
                upper_level /= step;
                temp_max = f[var_x] + g[k_mul - var_x] + (table[month+1][lower_level][2] * (upper_level*step - tmp) + table[month+1][upper_level][2] * (tmp - lower_level*step)) / step;
            } else
                temp_max = f[var_x] + g[k - var_x];
            //если сумма больше максимума, то записываем в таблицу
            if (max < temp_max){
                max = temp_max;
                table[month][k][0] = k_mul * step;
                table[month][k][1] = var_x * step;
                table[month][k][2] = max;
            }
        }
        //т.к. функция возрастает и выпукла вверх, можно начинать с предыдущего х
        if(month>1)
            var_x = (int)table[month][k][1] / step;
    }
    inverse<<"\nk"<<month<<"\tx"<<month<<"\tP(x)\n";
    for (int i = 0; i < k_to + 1; i++)
        inverse<<table[month][i][0]<<"\t"<<table[month][i][1]<<"\t"<<table[month][i][2]<<"\n";
}

void nline(int line){
    int dir_lower_level, dir_upper_level;

    optimize[line][0] = line+1;
    optimize[line][1] = optimize[line-1][6] + optimize[line-1][7];
    dir_lower_level = (int)floor(optimize[line][1]);
    while ( dir_lower_level % step ) dir_lower_level--;
    //шаг у k и х одинаковый, целое значение + добавляем остаток
    optimize[line][2] = table[line+1][(int)(dir_lower_level / step)][1] + (optimize[line][1] - dir_lower_level);
    optimize[line][3] = optimize[line][1] - optimize[line][2]; //y окажется целым
    dir_lower_level = (int)floor(optimize[line][2]); //верхний и нижний пределы для х, строим линейную аппроксимацию
    dir_upper_level = (int)ceil(optimize[line][2]);
    while ( dir_lower_level % step ) dir_lower_level--;
    while ( dir_upper_level % step ) dir_upper_level++;
    optimize[line][4] = (f[(int)(dir_lower_level / step)] * (optimize[line][2] - dir_lower_level) + f[(int)(dir_upper_level / step)] * (dir_upper_level - optimize[line][2])) / step;
    optimize[line][5] = g[(int)(optimize[line][3] / step)];
    if(line < 3){
        optimize[line][6] = (phi[(int)(dir_lower_level / step)] * (optimize[line][2]-dir_lower_level) + phi[(int)(dir_upper_level / step)] * (dir_upper_level-optimize[line][2])) / step;
        optimize[line][7] = psi[(int)(optimize[line][3] / step)];
    }else{
        optimize[line][6] = 0;
        optimize[line][7] = 0;
    }
}

void normal(){
    cout<<"Прямое планирование...\n";
    // 1 строка
    optimize[0][0] = 1; //i
    optimize[0][1] = table[1][0][0]; //k
    optimize[0][2] = table[1][0][1]; //x
    optimize[0][3] = optimize[0][1] - optimize[0][2]; //y
    optimize[0][4] = f[(int)(optimize[0][2] / step)]; //f(x)
    optimize[0][5] = g[(int)(optimize[0][3] / step)]; //g(x)
    optimize[0][6] = phi[(int)(optimize[0][2] / step)]; //phi(x)
    optimize[0][7] = psi[(int)(optimize[0][3] / step)]; //psi(x)
    nline(1); // 2 строка
    nline(2); // 3 строка
    nline(3); // 4 строка
    // вывод
    direct<<"i\tk\tx\ty\tf(x)\tg(y)\tphi(x)\tpsi(y)\n";
    for(int i=0; i<4; i++){
        direct<<i<<"\t";
        for(int j=1; j<8; j++)
            direct<<optimize[i][j]<<"\t";
        direct<<"\n";
    }
}

int main(){

    ifstream input("input.txt");
    if (!input.is_open()){
        cout<<"Файл не найден!\n";
        return 1;
    }

    for(int i=0; i<temp_count; i++) input>>x[i]>>f[i];
    for(int i=0; i<temp_count; i++) input>>x[i]>>g[i];
    for(int i=0; i<temp_count; i++) input>>x[i]>>phi[i];
    for(int i=0; i<temp_count; i++) input>>x[i]>>psi[i];

    k_max = temp_count - 1; //k1
    step = x[1] - x[0]; //шаг между значениями k и x
    /* ОБРАТНОЕ ПЛАНИРОВАНИЕ */
    reverse(4);
    reverse(3);
    reverse(2);
    reverse(1);
    /* ПРЯМОЕ ПЛАНИРОВАНИЕ */
    normal();

    cout<<"Данные сохранены в direct.txt и inverse.txt.\n";
    return 0;
}