MatrixMinimaMethod by Me

#include <iostream>
#include <cstdlib>

using namespace std;

class MatrixMinima{
    int cost[10][10], capacity[10], requirement[10], allotment[10][10];
    int cap_size, req_size;
    public:
        MatrixMinima(int cap_size, int req_size);
        void input();
        void displayAllotment(bool show_cap_req = true);
        void displayCost();
        void computeTransportationCost();
        bool requirementFulfilled();
        // arr is assumed to be 1 indexed
        int minimumElementIn(int arr[], int size);
        // gives the index of the element in the cost matrix
        int indexOfElementInCostMatrix(int row_no, int element);
        int min(int num1, int num2);
};

int MatrixMinima::min(int num1, int num2){
    return num1 < num2 ? num1 : num2;
}

int MatrixMinima::minimumElementIn(int arr[], int size){
    int curr_min_ele = arr[1];
    for(int i = 2; i <= size; i++){
        if(arr[i] < curr_min_ele){
            curr_min_ele = arr[i];
        }
    }
    return curr_min_ele;
}

int MatrixMinima::indexOfElementInCostMatrix(int row_no, int element){
    int index = -1;
    for(int j = 1; j <= req_size; j++){
        if(cost[row_no][j] == element){
            index = j;
            break;
        }
    }
    return index;
}

MatrixMinima::MatrixMinima(int cap_size, int req_size){
    MatrixMinima::cap_size = cap_size;
    MatrixMinima::req_size = req_size;
    // Initializing cost, allotment, requirement, capacity matrix
    for(int i = 1; i <= cap_size; i++){
        capacity[i] = 0;
        requirement[i] = 0;
        for(int j = 1; j <= req_size; j++){
            cost[i][j] = 0;
            allotment[i][j] = 0;
        }
    }
}

void MatrixMinima::input(){
    cout << "Enter the elements of cost matrix, capacity, requirement-->\n" << endl;
    // Taking input in cost matrix
    for(int i = 1; i <= cap_size; i++){
        for(int j = 1; j <= req_size; j++){
            cout << "cost[" << i << "][" << j << "] = ";
            cin >> cost[i][j];
        }
    }
    // Taking input in capacity matrix
    for(int i = 1; i <= cap_size; i++){
        cout << "capacity[" << i << "] = ";
        cin >> capacity[i];
    }
    // Taking input in requirement matrix
    for(int i = 1; i <= req_size; i++){
        cout << "requirement[" << i << "] = ";
        cin >> requirement[i];
    }
}

void MatrixMinima::displayAllotment(bool show_cap_req){
    for(int i = 1; i <= cap_size; i++){
        for(int j = 1; j <= req_size; j++){
            cout << allotment[i][j] << "\t";
        }
        if(show_cap_req){
            cout << capacity[i];
        }
        cout << endl;
    }
    if(show_cap_req)
    {
        // Requirement
        for(int i = 1; i <= req_size; i++){
            cout << requirement[i] << "\t";
        }
    }
    cout << endl;
}

void MatrixMinima::displayCost(){
    for(int i = 1; i <= cap_size; i++){
        for(int j = 1; j <= req_size; j++){
            cout << cost[i][j] << "\t";
        }
        cout << endl;
    }
}

void MatrixMinima::computeTransportationCost(){
    int row = 1;
    int *t_arr = NULL;
    int min_element, index_of_min, min_allotment;
    int size;
    int iteration = 0;
    int index;
    while(!requirementFulfilled()){
        size = 0;
        index = 1;
        cout << "Allotment Matrix after iteration-" << iteration << "--->" << endl;
        displayAllotment();
        cin.get();
        cout << "\n\n\n";
        // Count the number of incomplete assignments in row 'row'
        for(int i = 1; i <= req_size; i++){
            if(allotment[row][i] == 0){
                size = size + 1;
            }
        }
        // Creating the temporary array to store it
        t_arr = new int[size + 1];
        // Copying those costs in t_arr for which allotment is 0
        for(int i = 1; i <= req_size; i++){
            if(allotment[row][i] == 0){
                t_arr[index] = cost[row][i] ;
                index++;
            }
        }
        // Displaying the t_arr elements
        cout << "\n\nt_arr = ";
        for(int i = 1; i <= size; i++){
            cout << t_arr[i] << " ";
        }
        cout << "\n\n\n";
        min_element = minimumElementIn(t_arr, size);
        index_of_min = indexOfElementInCostMatrix(row, min_element);
        min_allotment = min(capacity[row], requirement[index_of_min]);
        allotment[row][index_of_min] = min_allotment;
        // Adjusting capacity and requirement
        capacity[row] = capacity[row] - min_allotment;
        requirement[index_of_min] = requirement[index_of_min] - min_allotment;

        if(capacity[row] == 0){
            row = row + 1;
        }
        if(requirement[index_of_min] == 0){
            int next_min;
            // Copy contents of t_arr in temp
            int *temp[] = new int[size];
            for(int i = 1; i <= size; i++){
                temp[i] = t_arr[i];
            }
            delete[] t_arr;
            size = size - 1;
            t_arr = new int[size];
            index = 1;
            for(int i = 1; i <= size; i++){
                if(temp[i] != min_element){
                    t_arr[index] = temp[i];
                    index++;
                }
            }
            // Displaying the t_arr elements
            cout << "\n\nt_arr = ";
            for(int i = 1; i <= size; i++){
                cout << t_arr[i] << " ";
            }
            cout << "\n\n\n";
            min_element = minimumElementIn(t_arr, size);
            index_of_min = indexOfElementInCostMatrix(row, min_element);
            min_allotment = min(capacity[row], requirement[index_of_min]);
            allotment[row][index_of_min] = min_allotment;
            // Adjusting capacity and requirement
            capacity[row] = capacity[row] - min_allotment;
            requirement[index_of_min] = requirement[index_of_min] - min_allotment;
        }
        iteration = iteration + 1;
        delete[] t_arr;
    }
}

bool MatrixMinima::requirementFulfilled(){
    bool req = true, cap = true;
    // Checking if all the elements of the requirement matrix is 0
    for(int i = 1; i <= req_size; i++){
        if(requirement[i] != 0){
            req = false;
            break;
        }
    }
    // Checking if all the elements of the capacity matrix is 0
    for(int i = 1; i <= cap_size; i++){
        if(capacity[i] != 0){
            cap = false;
            break;
        }
    }
    return req && cap;
}


int main() {
    system("cls");
    cout << "Enter the number of capacities(1-9) = ";
    int cap;
    cin >> cap;
    cout << "Enter the number of requirements(1-9) = ";
    int req;
    cin >> req;
    MatrixMinima obj(cap, req);
    obj.input();
    obj.computeTransportationCost();
    return 0;
}