How to solve this problem

Airport is divided to many Runways. Each runway has a mixed fixed delay amount of
time to keep a plane on runway. If airplane delay time > runway delay time than airplane
needs to take out from a runway, then it is considered as missed and starts from again
from a runway. You need to find out the minimum total delay for particular input. First
input line is number of runways. Second input line is delay of each runway.
Third input line is capacity of each runway to accommodate planes. Forth input line is
total number of planes. Fifth input line is maximum delay an airplane can afford. If it
exceed the runway delay time it is miss and it needs to start from again from a runway.
You need to show how you managed the runways as output as well.
Examples:(All are from user input)
5
2 2 3 5 7
2 2 2 2 2
8
1 1 1 1 2 2 3 3
Answer= 3

calculetion:(For another Example)
      2 2 3 5 7   (runways delay times)
     ____________
      1 1 1 5 3  (Air planes Delay times are less or equal
      1 2 2 0 0  than runways delay)
      __________
1sec -0 0 0 4 2
1sec -0 1 1 3 1
1sec -0 0 0 2 0
1sec -0 0 0 1 0
1sec -0 0 0 0 0 
________________
Dealay Time=(1+1+1+1+1)sec
           =5 second
Answer=5

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int numOfRun,numOfPl,minDl=0;
    int DR[10000],CP[10000],DP[10000],A[10000];
    cin>>numOfRun;
    for(int i=0;i<numOfRun;i++)
    {
        cin>>DR[i];
    }
    for(int i=0;i<numOfRun;i++)
    {
        cin>>CP[i];
    }
    cin>>numOfPl;
    for(int i=0;i<numOfPl;i++)
    {
        cin>>DP[i];
    }
    for(int i=0,j=0,k=0;i<numOfPl;k++,j++)
    {
        if(j>=numOfRun)
        {
            j=0;
        }
        if(DP[i]<=DR[j]&&CP[j]>0)
        {
            CP[i]--;
            A[k]=DP[i];
            i++;
        }
        else
        {
            minDl+=DP[i];
        }
    }
    cout<<"Answer = "<<minDl<<endl;
    for(int i=0,k=0;k<numOfPl;)
    {
        for(int j=0;j<numOfRun;j++,i++)
        {
            if(A[i]<=0)
                cout<<"  ";
            else
            {
             cout<<A[i]<<" ";
             k++;
            }
        }
        cout<<endl;
    }

    return 0;
}

#include<iostream>

using namespace std;

// Node class
class Node{
    public:
        float value;
        Node *next;
};

// Queue class
class Queue{
    public:
        // Pointer to keep track of the first value
        Node *first=NULL;

    // This function appends an integer at the end of the queue
    void enqueue(float d){
        Node *n = new Node();
        n->value = d;
        n->next = NULL;
        if(first == NULL){
            first = n;
        }else{
            Node *p = first;
            while(p->next != NULL){
                p=p->next;
            }
            p->next = n;
        }
    }

    // This function removes and returns the first value in the queue
    float dequeue(){
        if(first == NULL){
            //cout << "Queue is empty!" << endl;
            return -1;
        }
        Node *p = first;
        first = first->next;
        float v=p->value;
        delete p;
        return v;
    }

    int getSize(){
        if(first == NULL){
            return 0;
        }else{
            Node *p = first;
            int count=0;
            while(p != NULL){
                p=p->next;
                count++;
            }
            return count;
        }
    }

    int getSum(){
        int sum=0;
        if(first!=NULL){
            Node *p = first;
            while(p!=NULL){
                sum+=p->value;
                p=p->next;
            }
        }
        return sum;
    }
};

int getMax(int A[], int n){
    int max=A[0];
    for(int i=0;i<n;i++){
        if(max<A[i])
            max=A[i];
    }
    return max;
}

int getMaxTotalDelay(Queue Q[], int n, int planeDelay, int runwayIndex){
    int max=0;
    int sum;
    for(int i=0;i<n;i++){
        if(runwayIndex==i){
            sum=Q[i].getSum()+planeDelay;
        }
        else{
            sum=Q[i].getSum();
        }
        if(max<sum)
            max=sum;
    }
    return max;
}

int main(){
    int runway,plane;
    runway=5;
    plane=10;
    int runwaydelay[]    = {2,2,3,5,7};
    int runwayCapacity[] = {2,2,2,2,2};
    int planedelay[]     = {1,1,1,3,3,1,2,2,2,2};
    int nQc=0;
    Queue pDelay;
    for(int i=plane-1;i>=0;i--){
        pDelay.enqueue(planedelay[i]);
    }
    Queue Q[runway];
    int maxRunwayCapacity = getMax(runwayCapacity,runway);

    while(pDelay.getSize()>0){
        int minDelay = 99999;
        int minTotalDelay = 99999;
        int minTotalDelayIndex = 99999;
        int minDelayIndex = -1;
        int delay = pDelay.dequeue();
        for(int i=0; i<runway; i++){
            minTotalDelay=99999;
            for(int j=0;j<runway;j++){
                if(runwayCapacity[j]>Q[j].getSize() && runwaydelay[j]-delay>=0){
                    int mtd = getMaxTotalDelay(Q,runway,delay,j);
                    if(minTotalDelay>mtd){
                        minTotalDelay=mtd;
                        minTotalDelayIndex=j;
                    }
                }
            }
            if(runwaydelay[i]-delay>=0 && minDelay>runwaydelay[i]-delay && runwayCapacity[i]>Q[i].getSize()){
                minDelay = runwaydelay[i]-delay;
                minDelayIndex = i;
            }
        }
        if(minDelayIndex==-1){
            cout<<"Impossible"<<endl;
        }else{
            if(getMaxTotalDelay(Q,runway,delay,minDelayIndex)<getMaxTotalDelay(Q,runway,delay,minTotalDelayIndex)){
                cout<<"Plane delay: "<<delay<<" | Runway delay: "<<runwaydelay[minDelayIndex]<<" | Runway index: "<<minDelayIndex<<endl;
                Q[minDelayIndex].enqueue(delay);
            }else{
                cout<<"Plane delay: "<<delay<<" | Runway delay: "<<runwaydelay[minTotalDelayIndex]<<" | Runway index: "<<minTotalDelayIndex<<endl;
                Q[minTotalDelayIndex].enqueue(delay);
            }
        }
    }
    cout<<endl;
    for(int i=0;i<runway;i++){
        cout<<runwaydelay[i]<<",";
    }
    cout<<endl;
    for(int i=0;i<runway;i++){
        cout<<runwayCapacity[i]<<",";
    }
    cout<<endl;
    for(int i=0;i<plane;i++){
        cout<<planedelay[i]<<",";
    }
    cout<<endl;
    int minTotalDelay = getMaxTotalDelay(Q,runway,0,0);
    int r = runway;
    int c = getMax(runwayCapacity,runway);
    int outputArray[r][c];
    for(int i=0;i<r;i++){
        for(int j=0;j<c;j++){
            outputArray[i][j]=-1;
        }
    }
    for(int i=0;i<r;i++){
        for(int j=0;j<c;j++){
            int temp = Q[i].dequeue();
            if(temp > 0)
                outputArray[i][j]=temp;
        }
    }
    cout<<endl;
    for(int i=0;i<c;i++){
        for(int j=0;j<r;j++){
            if(outputArray[j][i]>0)
                cout<<outputArray[j][i]<<" ";
            else
                cout<<"  ";
        }
        cout<<endl;
    }
    cout<<"Minimum total delay: "<<minTotalDelay<<endl;