Ajuda com os 3 Jarros infernais!

Programação Java
#1

Ae pessoal, to com um probleminha que virou um problemão.

o problema não é tanto com a implementação e sim com o algoritmo.

Eu tenho o seguinte problema: Tenho 3 jarros d’água.

  • a agua não pode ser jogada fora
  • não posso receber agua de lugar nenhum
  • so pode esvaziar um jarro em outro, ou completar até a borda

ou seja, tenho 3 vazos e tenho que manipular agua entre eles.

Ex: tenho essa entrada

06 10 15
05 07 08
00 05 15

1ª linha - capacidade dos jarros
2ª linha - qta agua tem nos jarros
3ª linha - qta agua cada jarro tem q ficar no final.

essa foi facil ver que é soh jogar a agua do 2º no 3º e dps do 1º no segundo, ou seja, executei 2 movimentos.

é este o algoritmo que não consigo fazer, ler estas informações (isso ja faz) e calcular qtos movimentos são necessários para q os jarros fiquem com qtidade de agua final.

eu tenho que fazer este algoritmo funcionar com 10 entradas diferentes.

vlw pela ajuda

abraços

#2

Kara vê se é + ou - isso q vc quer? Só postei o código pq eu tinha aki pq por acaso encontrei nos arquivos da faculdade… acostuma não!! :smiley:

Realize as implementações que vc necessita e manda ver :thumbup:

import javax.swing.JOptionPane;
import java.lang.Math;
public class IA
{
 public static void main(String [] args)
  {
    int g1=0,g2=0,g3=0,xg1,xg2,xg3,a,b,c,op,q=0;
    String garrafa1,garrafa2,garrafa3,xgarrafa1,xgarrafa2,xgarrafa3,resp;
    garrafa1=JOptionPane.showInputDialog("Maximo que Garrafa1 deve ter");
    garrafa2=JOptionPane.showInputDialog("Maximo que Garrafa2 deve ter");
    garrafa3=JOptionPane.showInputDialog("Maximo que Garrafa3 deve ter");
    a=Integer.parseInt(garrafa1);
    b=Integer.parseInt(garrafa2);
    c=Integer.parseInt(garrafa3);
    xgarrafa1=JOptionPane.showInputDialog("valor final que Garrafa1 deve ter");
    xgarrafa2=JOptionPane.showInputDialog("valor final que Garrafa2 deve ter");
    xgarrafa3=JOptionPane.showInputDialog("valor final que Garrafa3 deve ter");
    xg1=Integer.parseInt(xgarrafa1);
    xg2=Integer.parseInt(xgarrafa2);
    xg3=Integer.parseInt(xgarrafa3);
    System.out.println(" SISTEMA DE BUSCA ");
    System.out.println(" OPCOES DE SISTEMA ");
    System.out.println(" OPCAO 1 -> ENCHE GARRAFA A");
    System.out.println(" OPCAO 2 -> ENCHE GARRAFA B");
    System.out.println(" OPCAO 3 -> ENCHE GARRAFA c");
    System.out.println(" OPCAO 4 -> A->B");
    System.out.println(" OPCAO 5 -> A->C");
    System.out.println(" OPCAO 6 -> B->C");
    System.out.println(" OPCAO 7 -> B->A");
    System.out.println(" OPCAO 8 -> C->A");
    System.out.println(" OPCAO 9 -> C->B");
    System.out.println(" OPCAO 10 -> ESVAZIA GARRAFA A");
    System.out.println(" OPCAO 11 -> ESVAZIA GARRAFA B");
    System.out.println(" OPCAO 12 -> ESVAZIA GARRAFA C");
    System.out.println(" OPCAO 0-> SAIR DO SISTEMA ");		
     op=0;
	do{ 
         switch(op)
            {
             case 1: //enche a
	  	g1=a;
                break;
             case 2: //enche b 
	 	g2=b;
                break;
             case 3: //enche c
	 	g3=c;
                break;
             case 4: //a->b
                 if (a>b)
                 {             g2=b;
                                g1=a-b;
   		g2=Math.abs(g2);
                        break;
                 }
             case 5: //a->c
                 if(a>c)
                 {     g3=c;
                        g1=a-c;
	   		}
                 else
                 {	if(a<c)
                           g3=g3+a;
		}	break;						   				
	    case 6: //b->c
                if(b>c) 
                {      g3=c;
                        g2=b-c;	   			
   		}
                else
                {   if(b<c)
                        g3=g3+b;
   		}	break;
            case 7://b->a
                if(b>a)
                {      g1=a;
                        g2=b-a;
   		}
                else
                {   if(b<a)
                      g1=g1+b;
   		}	break;
           case 8: //c->a
               if(c>a)
               {       g1=a;
                        g3=c-a;
   		}
               else
               {    if(c<a)
                       g1=g1+c;
   		}	break;
           case 9: //c->b
		if(c>b)
	 	{   g2=b;
                                     g3=b-c;
   		}
   		else
   		{   if(c<b)							   	   
                                       g2=g2+c;
		}   break;
            case 10: //esvazia a
		g1=0;
		break;
            case 11: //esvazia b
		g2=0;
		break;
            case 12: //esvazia c
		g3=0;
		break;		
		}			
JOptionPane.showMessageDialog(null,"SITUACAO GARRAFA A = "+g1);
JOptionPane.showMessageDialog(null,"SITUACAO GARRAFA B = "+g2);
JOptionPane.showMessageDialog(null,"SITUACAO GARRAFA C = "+g3);
	q++;	
	resp=JOptionPane.showInputDialog("opcao ? ");
	op=Integer.parseInt(resp);					       
	}while((op!=0)||(g1==xg1)&&(g2==xg2)&&(g3==xg3));
	System.out.println("QUANTIDADE: "+q);
    }
}
#3

Oras… faz um algoritmo que faça “backtracking” e tá resolvido.

Duvido que ele fique mais do que alguns minutos (se chegar a um minuto) tentando resolver qualquer situação (que tenha solução).

Afinal… um dos motivos de termos poder de processamento de sobra é poder gastar menos tempo pensando. :smiley:

#4

Sim, mas poder de processamento humano ainda é - muito - caro. Então, se não é pra se preocupar com a otimização do código, faça o favor de escrever código decente e legível por outros.

#5

Sim, mas poder de processamento humano ainda é - muito - caro. Então, se não é pra se preocupar com a otimização do código, faça o favor de escrever código decente e legível por outros.[/quote]

Independente disso, se você é pago para fazer uma tarefa, faça-a bem feita.

#6

Obviamente, “bem feita” é um conceito muito subjetivo e que valeria páginas de discussão aqui.

Por que subir o nível de abstração até esse ponto? Assim começaremos uma discussão teórica, abstrata, conceitual… enfim… inútil. Vamos nos ater ao problema inicial.

Por que a solução utilizando “backtracking” não seria aceitável?

#7

Ok, desculpe. Não estou me preocupando muito com a solução (mesmo porque o problema apresentado é um típico CSP, logo faz sentido usar a sua solução). É que eu já ouvi a seguinte frase:

Pelo menos umas 3 vezes esta semana e isso me deixa muito frustrado. Mas, enfim, deixa para lá. Vamos voltar ao foco da questão :slight_smile:

#8

Concordo com o Daniel. Esse tipo de pensamento deve ser combatido.
Leiam esse texto do Dijkstra
http://www.cs.utexas.edu/users/EWD/transcriptions/EWD03xx/EWD340.html
(Se alguem perguntar quem foi Dijkstra como fizeram no meu cliente anterior, eu mato!)

#9

É algum tipo de treinamento pra maratona de programação ? Vc vai participar ?

[quote=bzanchet]
Afinal… um dos motivos de termos poder de processamento de sobra é poder gastar menos tempo pensando. :D[/quote]

Bom, se for pra maratona esse é mais um bom motivo para se pensar no uso dos recursos, pois lá há restrição.

#10