Ir para o conteúdo
sara_sp

Á compras no supermercado - programa java

Mensagens Recomendadas

sara_sp    0
sara_sp

Alguem me consegue ajudar neste problema? Falta-me resolver a flag 2

O problema

Um supermercado possui
N
caixas de pagamento, numeradas consecutivamente de 1 a
N
. Cada uma destas caixas possui uma fila de clientes, sendo que no início todas as filas estão vazias.

C
clientes estão a efectuar compras neste supermercado. Cada cliente é identificado por um nome, um tempo de chegada (em segundos) às caixas e número de produtos para pagar. Assim que um cliente chega à zona das caixas para pagar, ele escolhe a caixa que possui a fila com menos clientes e, em caso de empate, aquela em que o último cliente da fila tem o menor número de produtos. Se mesmo assim persistir um empate, deve escolher a fila com o menor número de ordem.

Um cliente com
P
produtos demora
10 + P*K
i
segundos a ser atendido na caixa
i
, onde
K
i
é uma constante que define quantos segundos o operador da caixa
i
demora a processar um único produto, e 10 é o tempo constante necessário para o cliente proceder ao pagamento.

Se num mesmo segundo chega um cliente e um outro acaba as suas compras, deve processar primeiro o cliente que chega e só depois considerar o que termina.

Para resolver o problema pode usar listas genéricas do Java e é aconselhável que implemente pelo menos 3 classes: Cliente (um único cliente), Caixa (uma única caixa contendo uma fila de clientes), e Prob115 (que contém o método main).

Input

A primeira linha do input contém o valor de uma
flag
que pode tomar os valores 1 ou 2. Este valor indica qual a subtarefa que deve resolver.

A segunda linha contém um inteiro
N
, o número de caixas a considerar. A terceira linha contém
N
inteiros separados por um espaço, sendo que o
i
-ésimo inteiro da linha representa
K
i
, a rapidez de atendimento da caixa
i
.

A quarta linha contém um inteiro
C
, o número de clientes. Seguem-se
C
linhas, cada uma contendo a descrição de um cliente no formato "NOME SEGUNDO_CHEGADA NUMERO_PRODUTOS", onde NOME, é uma sequência contíguas de caracteres (sem espaços) e SEGUNDO_CHEGADA e NUMERO_PRODUTOS números inteiros indicando respectivamente o segundo de chegada e o número de produtos do cliente. É garantido que os clientes vêm no input por ordem estritamente crescente do segundo de chegada.

Output

O output depende do valor da flag dada no input:

No caso do valor da
flag ser 1
, pode assumir que apenas existirá uma caixa no supermercado. Devem ser escritas
C
linhas, uma por cada cliente, no formato "NOME TEMPO_CHEGADA TEMPO_SAIDA", onde o TEMPO_SAIDA é o segundo onde o cliente termina o seu atendimento.

No caso do valor da
flag ser 2
, deve escrever
N
linhas, uma por cada caixa. Cada uma destas linhas deve vir no formato "Caixa #i NUM_CLIENTES TOTAL_PRODUTOS", onde
i
é o número de ordem da caixa, NUM_CLIENTES é o número total de clientes atendidos nessa caixa e TOTAL_PRODUTOS é o número total de produtos desses mesmos clientes.

Input

2

3

1 1 1

6

Eduardo 5 4

Kyara 11 3

Rafaela 14 5

Nuria 18 5

Lucas 19 3

Barbara 28 4

Output

Caixa #1: 3 11

Caixa #2: 2 8

Caixa #3: 1 5

O meu programa para ja esta assim e não consigo resolver este erro:

import java.util.*;

class P115{

public static void main(String[] args){

Scanner inp = new Scanner (System.in);

int flag = inp.nextInt();
int ncaixas = inp.nextInt();

Caixa [] caixas = new Caixa[ncaixas];
int k;

for(int i=0; i < ncaixas; i++){
//lentidao de cada caixa
k = inp.nextInt();
caixas[i] = new Caixa(k);
}

int nClientes = inp.nextInt();

LinkedList<Cliente> porAtender = new LinkedList<Cliente>();
String nome;
int tempo_chegada, nprodutos;
Cliente novoCliente;

for (int i = 0; i< nClientes; i++){
nome = inp.next();
tempo_chegada = inp.nextInt();
nprodutos = inp.nextInt();

novoCliente = new Cliente (nome, tempo_chegada, nprodutos);

porAtender.addLast(novoCliente);
}

Subtarefas.resolve(flag, ncaixas, caixas, porAtender);
}
}

class Cliente{

//nome + tempo chegada (S) a caixa + n produtos
String nome;
int tempo_chegada, tempo_atendimento, nprodutos, tempo_saida;

Cliente(String n, int t, int p){
nome = n;
tempo_chegada = t;
nprodutos = p;
//tempo_atendimento = -1;
tempo_saida = -1;
}
}

class Caixa{
int k, total_produtos;

int num_clientes; //flag2
int tempSai; //flag2
LinkedList<Cliente> atendidos;

//Sa recebe primeiro a lentidao
Caixa(int lent){
k = lent;
atendidos = new LinkedList<Cliente>();
total_produtos = 0;
num_clientes = 0; //flag2
tempSai = 0; //flag2

}
}

class Subtarefas{

public static int escolherCaixa(int ncaixas, Caixa[] caixas){

int menorFila = caixas[0].atendidos.size();
int nordem = 0;

for(int i=0;i<ncaixas;i++){
if(caixas[i].atendidos.size() < menorFila){
menorFila = caixas[i].atendidos.size();
nordem = i;
}
if(caixas[i].atendidos.size() == menorFila){
if(caixas[i].atendidos.getLast().nprodutos < caixas[menorFila].atendidos.getLast().nprodutos)
nordem = i;
if(caixas[i].atendidos.getLast().nprodutos == caixas[menorFila].atendidos.getLast().nprodutos)
nordem = 0;
}
}
return 0;
}

public static void resolve(int flag, int ncaixas, Caixa[] caixas, LinkedList<Cliente> porAtender) {
String nome;
int tempo_chegada, nprodutos;
Cliente novoCliente;


if(flag == 1){

int tempo_livre = 0;

while(!porAtender.isEmpty()){

novoCliente = porAtender.removeFirst();

if (novoCliente.tempo_chegada >= tempo_livre)
novoCliente.tempo_atendimento = novoCliente.tempo_chegada;
else
novoCliente.tempo_atendimento = tempo_livre;

novoCliente.tempo_saida = 10 + novoCliente.nprodutos * caixas[0].k + novoCliente.tempo_atendimento;

tempo_livre = novoCliente.tempo_saida;

caixas[0].atendidos.addLast(novoCliente);

//nome + tempo de chegada + tempo de saida
System.out.println (novoCliente.nome + " " + novoCliente.tempo_chegada + " " + novoCliente.tempo_saida);
}
}

if (flag == 2){

int t=0;
int por_atender = porAtender.size();
int i;
Cliente cli;
Cliente c;

while(por_atender > 0){

if(!porAtender.isEmpty() && (porAtender.getFirst().tempo_chegada == t)){

cli = porAtender.removeFirst();

i = escolherCaixa(ncaixas, caixas);
System.out.println(cli.nome);
caixas[i].atendidos.addLast(cli);

if(!caixas[i].atendidos.isEmpty() && (caixas[i].atendidos.getLast().tempo_saida >= cli.tempo_chegada))
caixas[i].tempSai += 10 + (caixas[i].k*cli.nprodutos);

else if(!caixas[i].atendidos.isEmpty())
caixas[i].tempSai = 10 + cli.tempo_chegada + (caixas[i].k*cli.nprodutos);

caixas[i].num_clientes ++;
caixas[i].total_produtos += cli.nprodutos;
cli.tempo_saida = caixas[i].tempSai;
caixas[i].atendidos.addLast(cli);
}

for(int l=0; l<ncaixas; l++){
if(!caixas[l].atendidos.isEmpty() && (caixas[l].atendidos.getFirst().tempo_saida == t)){
c = caixas[l].atendidos.removeFirst();
por_atender--;
System.out.println(c.nome);
}
}

t++;
}

for(int a = 0; a < ncaixas; a++)
System.out.println("Caixa #" + a + ": " + caixas[a].num_clientes + " " + caixas[a].total_produtos);
}
}
}

Editado por apocsantos
tag code + geshi

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!

Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.

Entrar Agora


×

Aviso Sobre Cookies

Ao usar este site você aceita os nossos Termos de Uso e Política de Privacidade. Este site usa cookies para disponibilizar funcionalidades personalizadas. Para mais informações visite esta página.