Задача про кубики

#include <iostream>
 
void Equalizer(int*, int , int, int, int, int&);
bool Check(int*, int);
 
void main() {
    int n, minAccept, maxAccept, sum = 0;
    int count = INT_MAX;
    int* actualMas;
 
    std::cin >> n;
    actualMas = new int[n];
 
    for(int i = 0; i < n; i++) {
        std::cin >> actualMas[i];
        sum += actualMas[i];
    }
    minAccept = sum / n;
    maxAccept = minAccept + !!(sum % n);
 
    Equalizer(actualMas, n, minAccept, maxAccept, 0, count);
 
    std::cout << count << std::endl;
}
 
void Equalizer(int* mas, int n, int minAccept, int maxAccept, int curCount, int& count) {
    if(Check(mas, n)) {
        count = curCount;
        return;
    }
    for(int i = 0; i < n; i++) {
        if(mas[i] > maxAccept) {
            int j = 1;
            while((i - j >= 0 || i + j < n) && curCount + j < count) {
                if(i - j >= 0 && mas[i - j] < maxAccept) {
                    mas[i]--;
                    mas[i - j]++;
                    Equalizer(mas, n, minAccept, maxAccept, curCount + j, count);
                    mas[i]++;
                    mas[i - j]--;
                }
                if(i + j < n && mas[i + j] < maxAccept) {
                    mas[i]--;
                    mas[i + j]++;
                    Equalizer(mas, n, minAccept, maxAccept, curCount + j, count);
                    mas[i]++;
                    mas[i + j]--;
                }
                j++;
            }           
        }
        if(mas[i] < minAccept) {
            int j = 1;
            while((i - j >= 0 || i + j < n) && curCount + j < count) {
                if(i - j >= 0 && mas[i - j] > minAccept) {
                    mas[i]++;
                    mas[i - j]--;
                    Equalizer(mas, n, minAccept, maxAccept, curCount + j, count);
                    mas[i]--;
                    mas[i - j]++;
                }
                if(i + j < n && mas[i + j] > minAccept) {
                    mas[i]++;
                    mas[i + j]--;
                    Equalizer(mas, n, minAccept, maxAccept, curCount + j, count);
                    mas[i]--;
                    mas[i + j]++;
                }
                j++;
            }
        }
    }
}
 
bool Check(int* mas, int n) {
    int min = 0, max = 0;
    for(int i = 1; i < n; i++) {
        if(mas[min] > mas[i]) min = i;
        if(mas[max] < mas[i]) max = i;
    }
    if(mas[max] - mas[min] > 1) return false;
    return true;
}

// ConsoleApplication1.cpp: определяет точку входа для консольного приложения.
//
 
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
 
struct move;
 
#define CRCT_MOVES 8
#define COLUMNS 5
#define UPPERSIDE 1
#define DOWNSIDE 0
 
int columns[COLUMNS] = {3,2,11,4,2};
 
void print_columns()
{
    for (int i = 0; i < COLUMNS; ++i)
    {
        std::cout << columns[i];
        std::cout << ((i != COLUMNS - 1) ? ":" : "");
    };
};
 
void print_columns(int step)
{
    std::cout << "step " << step << ": ";
    print_columns();
};
 
float Hmedian;
int Hmin;
int Hmax;
float FHmin;
float FHmax;
 
int minimum_steps = 0x10;
std::vector<move> minimum_chain;
 
bool side(int column)
{
    if ((FHmax + FHmin) / 2 < columns[column]) return UPPERSIDE;
    else return DOWNSIDE;
};
 
bool quality_move(int dst_column, int src_column)
{
    if (columns[src_column] == 0) return 0;
    if (side(src_column) == UPPERSIDE)
    {
        return columns[src_column] >= columns[dst_column];
    }
    else
    {
        return columns[src_column] <= columns[dst_column];
    };
};
 
bool in_range(int column)
{
    return columns[column] == Hmin || columns[column] == Hmax;
};
 
bool all_in_range()
{
    for (int i = 0; i < 5; ++i)
    {
        if (!in_range(i)) return false;
    };
    return true;
};
 
std::vector<move> move_chain;
 
struct move
{
    int dst;
    int src;
    move(int _dst, int _src) : dst(_dst), src(_src) {};
    move() {};
 
    void do_move()
    {
        --columns[src];
        ++columns[dst];
        //move_chain.push_back(*this);
    };
 
    void un_move()
    {
        ++columns[src];
        --columns[dst];
        //move_chain.pop_back();
    };
 
    bool quality()
    {
        return quality_move(dst, src);
    };
};
 
move correct_moves[CRCT_MOVES]
{
    move(0,1),
    move(1,2),
    move(2,3),
    move(3,4),
    move(4,3),
    move(3,2),
    move(2,1),
    move(1,0)
};
 
void step_of_recursion(int current_step)
{
    move mv;
    ++current_step;
    for (int i = 0; i < CRCT_MOVES; ++i)
    {
        mv = correct_moves[i];
        if (mv.quality())
        {
            mv.do_move();
            if (all_in_range())
            {
                minimum_steps = current_step;
                //minimum_chain = move_chain;
                printf("FIND!!!%d\r\n",current_step);
                mv.un_move();
                return;
            };
 
            if (current_step + 1 < minimum_steps)
                step_of_recursion(current_step);
            mv.un_move();
        };
    };
};
 
int main()
{
 
    for (int i = 0; i < 5; ++i)
        Hmedian += columns[i]; 
    Hmedian /= 5;
    Hmin = Hmedian;
    Hmax = Hmedian + 1;
    FHmin = Hmin;
    FHmax = Hmax;
 
    printf("median: %f\r\n", Hmedian);
    printf("Hmin: %d\r\n", Hmin);
    printf("Hmax: %d\r\n", Hmax);
 
 
    
    step_of_recursion(0);
    
    //int step = 0;
    //print_columns(step);
    //std::cout << "\r\n";
    //for_each(minimum_chain.begin(), minimum_chain.end(), [&step](move& m) 
    //{
    //  step++;
    //  m.do_move();
    //  print_columns(step); 
    //  std::cout << " dst:" << m.dst << " src:" << m.src << "\r\n";
    //});
 
    printf("THATS_ALL!!!\r\n");
    getchar();
    return 0;
}