Como implementar um solucionador de problemas de jarro de água em Java?

Como fornecedor de jarros de água, sempre fui fascinado pelos aspectos práticos e teóricos dos jarros de água. Um problema teórico interessante que tem implicações no mundo real é o problema do jarro de água. Neste blog, orientarei você na implementação de um solucionador de problemas de jarro de água em Java.

Compreendendo o problema do jarro de água

O problema do jarro de água é um quebra-cabeça clássico. São dados dois jarros com capacidades (x) e (y) litros, e um objetivo de medir (z) litros de água. As operações que você pode realizar são:

1. Encha uma jarra completamente.
2. Esvazie uma jarra.
3. Despeje água de um jarro para outro até que o jarro de origem esteja vazio ou o jarro de destino esteja cheio.

O objetivo é encontrar uma sequência dessas operações que resulte em (z) litros de água em uma das jarras.

Implementação Java do solucionador de problemas de jarro de água

Vamos começar criando uma classe para representar o estado dos jarros.

class JugState { int jug1; int jarro2; public JugState(int jug1, int jug2) { this.jug1 = jug1; isto.jarro2 = jarro2; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) retornar falso; JugState jugState = (JugState) o; return jar1 == jugState.jug1 && jug2 == jugState.jug2; } @Override public int hashCode() { return 31 * jug1 + jug2; } @Override public String toString() { return "Jarro1: " + jarro1 + ", Jarro2: " + jarro2; } }

EsseJarroEstadoclasse representa a quantidade atual de água em cada jarro. Nós substituímos oé igualecódigo hashmétodos para poder usar esses estados em estruturas de dados comoHashSet.

A seguir, implementaremos a classe principal do solucionador.

importar java.util.*; classe pública WaterJugSolver {private int capacidade1; capacidade interna privada2; alvo interno privado; public WaterJugSolver (int capacidade1, int capacidade2, int alvo) { this.capacity1 = capacidade1; esta.capacidade2 = capacidade2; este.target = alvo; } public List<JugState> resolve() { Queue<List<JugState>> fila = new LinkedList<>(); Set<JugState> visitado = new HashSet<>(); JugState estadoinicial = novo JugState(0, 0); List<JugState> caminhoInicial = new ArrayList<>(); caminhoinicial.add(estadoinicial); fila.add(caminhoinicial); visitado.add(initialState); while (!queue.isEmpty()) { List<JugState> currentPath = queue.poll(); JugState currentState = currentPath.get(currentPath.size() - 1); if (currentState.jug1 == alvo || currentState.jug2 == alvo) { return currentPath; } List<JugState> nextStates = getNextStates(currentState); for (JugState nextState: nextStates) { if (!visited.contains(nextState)) { List<JugState> newPath = new ArrayList<>(currentPath); novoPath.add(nextState); fila.add(novoCaminho); visitado.add(nextState); } } } retornar nulo; } private List<JugState> getNextStates(JugState currentState) { List<JugState> nextStates = new ArrayList<>(); // Preencha o jarro 1 nextStates.add(new JugState(capacity1, currentState.jug2)); // Preencha o jarro 2 nextStates.add(new JugState(currentState.jug1,capacidade2)); // Jarro vazio 1 nextStates.add(new JugState(0, currentState.jug2)); // Jarro vazio 2 nextStates.add(new JugState(currentState.jug1, 0)); // Despeje do jarro 1 para o jarro 2 int pourAmount = Math.min(currentState.jug1,capacidade2 - currentState.jug2); nextStates.add(new JugState(currentState.jug1 - pourAmount, currentState.jug2 + pourAmount)); // Despeje do jarro 2 para o jarro 1 pourAmount = Math.min(currentState.jug2,capacidade1 - currentState.jug1); nextStates.add(new JugState(currentState.jug1 + pourAmount, currentState.jug2 - pourAmount)); retornar próximos Estados; } public static void main(String[] args) { WaterJugSolver solucionador = new WaterJugSolver(3, 5, 4); List<JugState> solução = solucionador.solve(); if (solução! = Nulo) { for (estado JugState: solução) { System.out.println (estado); } } else { System.out.println("Nenhuma solução encontrada."); } } }

NoWaterJugSolverclasse, usamos um algoritmo de pesquisa em largura (BFS) para encontrar a solução. OresolverO método inicializa uma fila para armazenar os caminhos e um conjunto para rastrear os estados visitados. Começamos com o estado inicial de ambos os jarros vazios.

OgetNextStatesO método gera todos os próximos estados possíveis a partir do estado atual, executando as seis operações mencionadas anteriormente.

Aplicações do mundo real e nossos jarros de água

O problema do jarro de água pode parecer um quebra-cabeça simples, mas tem aplicações em áreas como gerenciamento e otimização de recursos. No contexto do nosso negócio de jarros de água, compreender esses algoritmos pode ajudar em cenários como o enchimento eficiente de recipientes de água em grande escala.

Oferecemos uma ampla gama de jarros de água para atender a diferentes necessidades. Para atividades ao ar livre, nossosJarro de água externo de aço inoxidável de grande capacidadeé uma ótima escolha. Ele pode reter uma quantidade significativa de água, garantindo que você se mantenha hidratado durante longas caminhadas ou acampamentos.

Se você precisar de uma opção mais portátil, nossoJarro portátil de aço inoxidável de 64 onçasé perfeito. É fácil de transportar, quer você esteja indo para a academia ou fazendo outras tarefas.

Para aqueles que precisam de ainda mais armazenamento de água, nossoGarrafa de água de aço inoxidável de 64 onças e 128 onças de galãofornece a capacidade que você precisa.

Conclusão

Implementar um solucionador de problemas de jarro de água em Java é uma ótima maneira de entender algoritmos como BFS e como eles podem ser aplicados a problemas do mundo real. Como fornecedor de jarros de água, temos o compromisso de fornecer produtos de alta qualidade que atendam às suas necessidades de armazenamento de água.

Se você estiver interessado em comprar nossos jarros de água ou tiver alguma dúvida sobre nossos produtos, encorajamos você a entrar em contato para uma discussão sobre compras. Estamos aqui para ajudá-lo a encontrar a solução de jarro de água perfeita para suas necessidades.

Referências

• Introdução aos Algoritmos por Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
• Estruturas de dados e algoritmos em Java por Robert Lafore