странное поведение программы

#define CPP2
#ifdef CPP2
#include <iostream>
#include <fstream>
#define cin std::cin
#define endl std::endl
typedef long double nint;
std::ofstream debugflow;
//using namespace std;



class chip{
    //input
    static int size;
    static int a,b;

    //arrays
    bool** grid;//of all active parts of chip
    bool** empty_grid;//of all empty sockets of chip
    int sum_empty;
    //bool* locked_line;
   


    int* sum_x;//sum of row
    int* sum_y;//sum of column
    int* delta_sum;//delta of sums row-column
    bool legal_balance;
    int* minimax_delta_x, *minimax_delta_y, *minimax_delta_value;


    int index_max_sum;//index of row/col which sum is max
    //bool max_sum_is_x;//previous is row/col
    int line_lim; //max legal by power sum of row/col
    int sum_all; //total number of elements
    bool legal_power;

    bool check_legal_balance(){
    for(int i=0; i<size; ++i){
            if(delta_sum!=0) return false;}
    return true;}

    /*bool get_minimax_delta_and_legal_balance(){

    min_delta=0; max_delta=0;

    int* temp=new int[size];
    int* number=new int[size];

    for(int i=0; i<size; ++i){
        if(max_delta<delta_sum)  {max_delta=delta_sum;}
        if(min_delta>delta_sum) {min_delta=delta_sum;}
            temp=delta_sum;
            number=i;
    }//i

    int temp_temp,temp_number;
    for(int i=0; i<size; ++i){
        for(int j=i+1; j<size; ++j){
            if(temp<temp[j]) {temp_temp=temp; temp=temp[j]; temp[j]=temp_temp;
            temp_number=number; number=number[j]; number[j]=temp_number;}}}//i//j

    for(int i=0; i<size; ++i){
        minimax_delta=number;}

    delete[] number;
    delete[] temp;

    if(max_delta==min_delta){
        legal_balance=true;
        return true;}
    return false;}*/

   
public:

    chip(int &nt, int &at, int &bt){
        size=nt;
        a=at;
        b=bt;

        grid=new bool* [size];
        empty_grid=new bool* [size];
        sum_x=new int[size];
        sum_y=new int[size];
        delta_sum=new int[size];
        minimax_delta_x=new int[size*(size-1)];
        minimax_delta_y=new int[size*(size-1)];
        minimax_delta_value=new int[size*(size-1)];
        sum_empty=0;
        sum_all=0;
        for(int i=0; i<size; ++i){ sum_x=0; sum_y=0;}

        char* temp=new char[size+1];
        //input by strings
        for(int i=0; i<size; ++i){
            cin>>temp;
            grid=new bool [size];
            empty_grid= new bool[size];
            for(int j=0; j<nt; ++j){
                switch (temp[j]){
                case '/': grid[j]=true; empty_grid[j]=false; break;
                case 'C': grid[j]=false; ++sum_all; empty_grid[j]=false; ++sum_x; ++sum_y[j]; ++sum_all; break;
                case '.': grid[j]=false; empty_grid[j]=true; ++sum_empty; break;
                default: std::cout<<"input error, incorrect symbol!\n"; exit(0); break;
                }}//j
        }//i       
        for(int i=0; i<size; ++i){delta_sum=sum_x-sum_y;}
        legal_balance=check_legal_balance();
        delete[] temp;

        //debug(); //DELETE!

    }

    void add_symmetric(){
        for(int i=0; i<size; ++i){
            for(int j=0; j<size; ++j){
                if(empty_grid[j] && empty_grid[j]){
                    empty_grid[j]=false;
                    empty_grid[j]=false;
                    ++sum_x;
                    ++sum_y;
                    ++sum_all;
                    --sum_empty;
                    if(i!=j){
                    ++sum_x[j];
                    ++sum_y[j];
                    ++sum_all;
                    --sum_empty;}}}}}

    void normalize_balance(){
        //int max_minimax_delta_value;
        //int max_minimax_delta_index;
        while(!check_legal_balance()&&sum_empty){
            int k=0;
            for(int i=0; i>size; --i){
                for(int j=0; j<size; ++j){
                    if(i!=j){
                        minimax_delta_value[k]=delta_sum-delta_sum[j];
                        minimax_delta_x[k]=i;
                        minimax_delta_y[k]=j;
                        ++k;}}}

            //сортировка пузырьком массива с разностью дельт!
        int temp,temp_x,temp_y;
        for(int i=0; i<k; ++i){
            for(int j=0; j<k; ++i){
                if(minimax_delta_value<minimax_delta_value[j]){
                    temp=minimax_delta_value;
                    temp_x=minimax_delta_x;
                    temp_y=minimax_delta_y;
                    minimax_delta_value=minimax_delta_value[j];
                    minimax_delta_x=minimax_delta_x[j];
                    minimax_delta_y=minimax_delta_y[j];
                    minimax_delta_value[j]=temp;
                    minimax_delta_x[j]=temp_x;
                    minimax_delta_y[j]=temp_y;}}}

               //заполнение ячейки гаджетом
        for(int i=0; i<(k/2); ++i){
            if(empty_grid[minimax_delta_y][minimax_delta_x]){
                empty_grid[minimax_delta_y][minimax_delta_x]=false;
                ++sum_x[minimax_delta_y];
                ++sum_y[minimax_delta_x];
                --delta_sum[minimax_delta_x];
                ++delta_sum[minimax_delta_y];
                --sum_empty;
                break;}}
        //debug();

        }}

    bool check_legal_power(){
        int limit_line=(nint(a*sum_all))/b;
        for(int i=0; i<size; ++i){
            if ((sum_x>limit_line)||(sum_y>limit_line)) return false;}
        return true;}
     
    void debug(){
        char* out=new char [size+1];
        out[size+1]='\n';
       
        for(int i=0; i<size; ++i){
            for(int j=0; j<size; ++j){
                if(empty_grid[j]) out[j]='O';
                else if(grid[j]) out[j]='X';
                else out[j]='P';
                  }
            debugflow<<out;}
    delete[] out;}

};

int chip::a, chip::b, chip::size;

int main(){
   
    debugflow.open("debug.txt");
    int nt,at,bt;
    cin>>nt>>at>>bt;
    chip conroe(nt,at,bt);
    conroe.debug();
    conroe.normalize_balance();
}


#endif

5 3 10
CC/..
././/
..C.C
/.C..
/./C/