Question

Unloading Merchandise and Delivery (UMD) is in charge of loading air planes and trains from containers that have been unloaded from ships. The material from the dock is stacked (up to 5 containers high) if it to be sent by train. The materials destined to be sent by planes are are unpacked and placed on an assembly line. Each item is labeled either a train number or plane number (which is its destination). Items destined for trains are placed in a stack until it reaches 5 items high, then a new stack is begun behind the original. Items are planes are placed on a long assembly line (there is only 1 assembly line). You can assume 1 worker is loading trains and 1 worker is loading the planes at the same time. The trains (planes) closer to the dock have the smaller train (plane) numbers Each worker requires 2 minutes x train number to move an item from the dock to a train and return. Each worker required 10 minutes x the plane number to move an item from the dock to a plane and return. Given the order that items are unloaded from the ship, your job is write a program to determine the total time it will take to load all the materials.

Input:

All input will be from the keyboard. The first line of input will be 4 integers (t,p and nt and np) (0 <= t < 100, 0 <= p < 10,0 <= nt,0 <= np) (each separated by a single space), which represent the total number of trains , the total number of planes and the total number of to be loaded into trains and the total number of items to be loaded into planes. The second line will contain t integers (again separated by a single space) representing the number of items to be loaded to each train. The third line will contain p integers (again separated by a single space) representing the number of items to be loaded to each plane. The fourth line will contain nt representing the destination of each item being sent by a train. The last line will contain np representing the destination of each item being sent by a plane.

Output:

Output will be on the screen in 2 lines. The first line contains nt integers each separated by 1 space. The ith integer represents the time the ith train finished loading. The second line contains np integers each separated by 1 space. The ith integer represents the time the ith plane finished loading.

sample Input

3 2 10 5 2 7 1 3 2 2 2 2 1 3 2 2 2 1 2 2 1 1 2 1

corresponding Output

25 36 3 65 50

c++ stacks queue linked list

Answer 1

Code:

#include <bits/stdc++.h>

using namespace std;

int main() {

int t;

int p;

int nt;

int np;

// Input number of planes/trains and items

cin >> t >> p >> nt >> np;

// Arrays to store capacities of each train/plane

int train_cap[t+1];

int plane_cap[p+1];

// Arrays to store answer for each train/plane

int train_ans[t+1];

int plane_ans[p+1];

// Arrays to store item's destinations for trains/planes

int train_item[nt+1];

int plane_item[np+1];

// Input data

for(int i = 1; i <= t; i++)

cin >> train_cap[i];

for(int i = 1; i <= p; i++)

cin >> plane_cap[i];

for(int i = 1; i <= nt; i++)

cin >> train_item[i];

for(int i = 1; i <= np; i++)

cin >> plane_item[i];

// Calculate answer for trains

int timer = 0;

for(int i = 1; i <= nt; i+=5) {

stack<int> trainStack;

// Create new stack with maximum 5 elements

for(int j = i; j <= min(i+4,nt); j++)

trainStack.push(j);

// Load items to the train from the stack

while(!trainStack.empty()){

// Take item from the stack

int j = trainStack.top();

// Remove item from the stack

trainStack.pop();

// Time to reach train

timer += train_item[j];

// If train is full store ans

train_cap[train_item[j]]--;

if(train_cap[train_item[j]] == 0)

train_ans[train_item[j]] = timer;

// Time to return back

timer += train_item[j];

}

}

// Calculate answer for planes

timer = 0;

queue<int> planeQueue;

// Create queue for plane

for(int i = 1; i <= np; i++)

planeQueue.push(i);

// Load items from plane to the queue

while(!planeQueue.empty()) {

// Take new item from queue

int i = planeQueue.front();

planeQueue.pop();

// Time to reach plane

timer += plane_item[i]*5;

// If plain is full store ans

plane_cap[plane_item[i]]--;

if(plane_cap[plane_item[i]] == 0)

plane_ans[plane_item[i]] = timer;

// Time to return back

timer = timer + plane_item[i]*5;

}

// Print answers

for(int i = 1; i <= t; i++)

cout << train_ans[i] << " ";

cout << "\n";

for(int i = 1; i <= p; i++)

cout << plane_ans[i] << " ";

cout << "\n";

}

Output:

____________________________
Comment down for any queries

Please give a thumb up