GUJ Discussões   :   últimos tópicos   |   categorias   |   GUJ Respostas

Array com vetores

java
Tags: #<Tag:0x00007f9d20958160>

#1

Me ajude ae Galera!
Preciso desenvolver um sistema com nome do gestor atual e quais cidades são vizinhas e qual a distância (em km) para essas cidades.
O sistema deve listar e mostrar na tela.
O meu está assim:Não consigo achar o erro.
Package JOptionPane;

import java.util.Scanner;
import javax.swing.JOptionPane;


public class Principal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        
        Object[] cidade = {"Cidade A","Cidade B", "Cidade C", "Cidade D", "Cidade E", "Cidade F", "Cidade G"}; 
              
        String c = String.valueOf(JOptionPane.showInputDialog(
        null, "Escolha a cidade desejada", "Escolha", JOptionPane.QUESTION_MESSAGE,null, cidade, cidade[1]));
        
        System.out.println(c);
        
        
        int d = (int)(Math.random()*30);
        JOptionPane.showMessageDialog(null, "A distancia do trajeto e de: " + d);
        
        System.out.println(d);
        
        String Gestor;
        String Habitantes;
        String Distancia;
        
        Gestor = JOptionPane.showInputDialog("Digite o nome do gestor");
        Habitantes = JOptionPane.showInputDialog("Digite a quantidade de habitantes");
        Distancia = JOptionPane.showInputDialog("Digite os kilometros percurso");
        
        JOptionPane.showMessageDialog(null, "O Gestor atual: " + Gestor + "\n Quantidade de Habitantes: " + Habitantes + "\n Distancia percorrida: " + d);
    
        String cidades [] = new String [7];
        cidade[0] = "A";
        cidade[1] = "B";
        cidade[2] = "C";
        cidade[3] = "D";
        cidade[4] = "E";
        cidade[5] = "F";
        cidade[7] = "G";
        
        Scanner sc = new Scanner(System.in);
        System.out.println("Escolha a cidade desejada");
        String op = sc.nextString
        
        
        
    }
}

s as cidades cadastradas e seus respectivos dados.O que eu fiz está assim.


#2

Eu encontrei 2 erros no seu código:
O Primeiro foi no tamanho do array String , vc digitou:

cidade[7] = "G";

O correto seria :

cidade[6] = "G";

Como o array é de tamanho 7 , ele vai percorrer de 0 a 6 : |0|1|2|3|4|5|6|.


O Segundo erro foi na ultima linha de código , vc digitou:

String op = sc.nextString

O correto seria:

String op = sc.next();

A leitura de uma String é implícita por isso vc não precisa declarar " nextString ".

Código corrigido abaixo :arrow_double_down:

import java.util.Scanner;
import javax.swing.JOptionPane;

public class Principal {

public static void main(String[] args) {
    
    
    Object[] cidade = {"Cidade A","Cidade B", "Cidade C", "Cidade D", "Cidade E", "Cidade F", "Cidade G"}; 
          
    String c = String.valueOf(JOptionPane.showInputDialog(
    null, "Escolha a cidade desejada", "Escolha", JOptionPane.QUESTION_MESSAGE,null, cidade, cidade[1]));
    
    System.out.println(c);
    
    
    int d = (int)(Math.random()*30);
    JOptionPane.showMessageDialog(null, "A distancia do trajeto e de: " + d);
    
    System.out.println(d);
    
    String Gestor;
    String Habitantes;
    String Distancia;
    
    Gestor = JOptionPane.showInputDialog("Digite o nome do gestor");
    Habitantes = JOptionPane.showInputDialog("Digite a quantidade de habitantes");
    Distancia = JOptionPane.showInputDialog("Digite os kilometros percurso");
    
    JOptionPane.showMessageDialog(null, "O Gestor atual: " + Gestor + "\n Quantidade de Habitantes: " + Habitantes + "\n Distancia percorrida: " + d);

    String cidades [] = new String [7];
    cidade[0] = "A";
    cidade[1] = "B";
    cidade[2] = "C";
    cidade[3] = "D";
    cidade[4] = "E";
    cidade[5] = "F";
    cidade[6] = "G";
    
    Scanner sc = new Scanner(System.in);
    System.out.println("Escolha a cidade desejada");
    String op = sc.next();
    
    }

}

#3

Funcionou?


#4

Ainda não ta faltando .Este projeto tem motrar a menor distancia entre as cidades vizinhas.Tipo:A>B>C>D.
Como consigo declarar para funcionar ?


#5

Para fazer a comparação das distancia entre as cidades , tem que declarar a a distancia de cada uma.


#6

Coloca a descrição completa do projeto que fica mais fácil de entender e te ajudar.


#7

O sistema deve ler as informações de todas as cidades: nome, número de habitantes, nome do gestor atual e quais cidades são vizinhas e qual a distância (em km) para essas cidades.
O sistema deve listar todas as cidades cadastradas e seus respectivos dados.
O sistema deve permitir a busca de uma determinada cidade no vetor de cidades e mostrar os dados obtidos como resultado da busca.
Utilize o método random para gerar as distâncias entre as cidades. O método deve receber como parâmetro no máximo o valor 30 e sempre gerar valores acima de 5. Toda vez que uma distancia entres as cidades for cadastrada ela deverá utilizar esse método aleatório.
O sistema deve mostrar o trajeto mais curto da cidade A até a cidade G, considerando que deve passar por todas as cidades. A saída dos dados deve ser mostrada de acordo com o exemplo abaixo. Supondo que o trajeto mais curto seja A, D, E, G:
A > D > E > G
Um menu de opções deve ser criado contendo todas as funcionalidades


#8

Este é o desenho


#9

Vou parafrasear outro participante, do fórum (staroski).
Você vai precisar implementar o algoritimo de Dijkstra.
É um conjunto de instruções que permite encontrar o caminho mais curto em um grafo (seu caso).

Outra coisa, você vai ter que controlar os “apontamentos”, arestas.
Ex.: o vertice A “aponta” para B e D, logo, são duas arestas saindo de A.
B aponta para C e F, logo, temos duas arestas partindo de B.
Se você não controlar isto, pode ser que G não se relacione indiretamente com A, e ai você não conseguiria partir de A e chegar a G.

Assim, você já tem o grafo, conhece os vertices {A,B,C,D,E,F,G} e suas arestas {(a,b),(a,d),(b,c),(b,f) …}.
Agora pode usar as instruções(algorítimo) de Djikstra, ele é legalzin.


#10

nuss .Vou reprovar


#11

Esse projeto é pra quando?


#12

Esta solução considera o algoritmo de Dijkstra e com uma pequena alteração foi possível pegar os caminhos da mesma forma que os calcula.
Deve haver codificações melhores, pois eu comecei a entender as instruções do código faz poucos dias apenas por curiosidade, além de não ser profissional da área, mas a codificação esta funcional e explicada.

Assim, estou compartilhando a codificação em java para que possa ser comparada com outras.

Classe de teste

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
import javax.swing.JFrame;


public class Crisis extends JFrame {
    public static void main(String[] args) {
        ArrayList<Vertice> grafo = new ArrayList<>();
        //adicionando os vétices ao grafo
        Collections.addAll(grafo, new Vertice("A"),new Vertice("B"),new Vertice("C"),
                new Vertice("D"),new Vertice("E"),new Vertice("F"),new Vertice("G"));
        
        float ponteBC, ponteCD;//NÃO é um problema mas preferi criar "pontes" para evitar caminhos "duplos"
        
        //gerando as arestas
        arestar(grafo.get(0), new Aresta("B", dist()), new Aresta("D", dist()));//A "aponta" para B e C
        arestar(grafo.get(1), new Aresta("F", dist()), new Aresta("C", ponteBC = dist()));//B para F e C
        arestar(grafo.get(2), new Aresta("B", ponteBC), new Aresta("D", ponteCD = dist()));//C para B e D
        arestar(grafo.get(3), new Aresta("C", ponteCD), new Aresta("E", dist()));//para D
        arestar(grafo.get(4), new Aresta("G", dist()));//E aponta para G
        arestar(grafo.get(5), new Aresta("G", dist()));//F aponta para G que nãp aponta para ninguém
        
        //procurando o menor caminho, a origem é A na posição 0 e destino é G não posição 6, neste exemplo        
        Vertice.menorCaminho(grafo.get(0), grafo.get(6), grafo);            
    }

    //método para auxiliar o preenchimento
    private static void arestar(Vertice vertice, Aresta ... arestas){
       vertice.getArestas().addAll(Arrays.asList(arestas));
    }

    //para auxiliar na distância aleatória
    private static float dist(){
        return new Random().nextInt(25) + 5;
    }
}

Classe que representará os vértices do grafo:

import java.util.ArrayList;
import java.util.Collections;
import javax.swing.JOptionPane;

public class Vertice implements Comparable<Vertice> {
    
    private final String referencia;
    private float peso;
    private final ArrayList<Aresta> arestas = new ArrayList<>();
    private String caminho = null;

    public Vertice(String referencia) {
        this.referencia = referencia;
    }

    public String getReferencia() {
        return referencia;
    }

    public float getPeso() {
        return peso;
    }

    public void setPeso(float peso) {
        this.peso = peso;
    }

    public ArrayList<Aresta> getArestas() {
        return arestas;
    }

    @Override//vai nos ajudar a identifica o menor peso usando o método sort (ordenar em ordem crescente)
    public int compareTo(Vertice outroVertice) {
        return Float.compare(peso, outroVertice.peso);
    }

    public static void menorCaminho(Vertice origem, Vertice destino, ArrayList<Vertice> grafo) {
        //primeiro todos os pesos do grafo são declarados como o maior valor possível
        grafo.forEach(vertice -> {
            vertice.peso = Float.POSITIVE_INFINITY;
        });

        //a variável origem deve estar contida no grafo e o peso dela é inicializado com 0
        origem.setPeso(0);
        origem.caminho = origem.referencia;//inicializando o caminho

        //vamos precisar de SOMENTE uma lista para atualizar o peso dos vértices
        ArrayList<Vertice> fila = new ArrayList<>(grafo);//todos os vertices foram adicionados à "FILA"

        //enquanto houver elementos na fila removemos o elemento com o menor peso e atualizamos os demais
        while (!fila.isEmpty()) {
            Vertice menor = verticeMaisLeve(fila);
            //vamos procurar os vertices vizinhos utilizando a referência como parâmetro
            for (Aresta aresta : menor.getArestas()) {//para cada aresta
                for (Vertice vertice : grafo) {//verificamos cada vertice no grafo, ou seja não verifico a fila e sim o grafo
                    if (vertice.getReferencia().equals(aresta.getReferencia())) {//filtro para atualização dos pesos pela referencia
                        if (vertice.peso > menor.peso + aresta.getDistancia()) {
                            vertice.setPeso(menor.peso + aresta.getDistancia());
                            vertice.caminho = menor.caminho + " > " + vertice.referencia;
                        }
                        break;
                    }
                }
            }
        }
        JOptionPane.showMessageDialog(null, "MENOR CAMINHO DE "+origem.getReferencia()+" a "
                + destino.referencia+"\n"+(destino.caminho == null? "As cidades não se comunicam ":destino.caminho)+" \n"); 
    }

    private static Vertice verticeMaisLeve(ArrayList<Vertice> fila) {
        //como implementamos o comparable, podemos usar ordenar a coleção com ferramentas do java
        Collections.sort(fila);//ordenando a fila de acordo com o peso de cada vétice
        return fila.remove(0);//retornamos o menor elemento da fila e o removemos da fila (obs.: em uma instrução)
    }
}

Classe que representará as arestas do grafo

public class Aresta {
private final String referencia;
private final float distancia;

    public Aresta(String referencia, float distancia) {
        this.referencia = referencia;
        this.distancia = distancia;
    }

    public float getDistancia() {
        return distancia;
    }

    public String getReferencia() {
        return referencia;
    }
}

#13

valeu deu uma clareada ak!


#14

até 8 /06


#15

Esta dando um erro ak.
public static void main(String[] args) {
Vertice origem;
Vertice destino;
ArrayList grafo;
String referencia;
Float peso;
ArrayList aresta;
String caminho;
ArrayList fila;

    **ArrayList <Vertice> grafo = new ArrayList[]();**
    //adicionando os vétices ao grafo
    Collections.addAll(grafo, new Vertice("A"),new Vertice("B"),new Vertice("C"),
            new Vertice("D"),new Vertice("E"),new Vertice("F"),new Vertice("G"));
    
    float ponteBC, ponteCD;//NÃO é um problema mas preferi criar "pontes" para evitar caminhos "duplos"
    
    //gerando as arestas
    arestar(grafo.get(0), new Aresta("B", dist()), new Aresta("D", dist()));//A "aponta" para B e C
    arestar(grafo.get(1), new Aresta("F", dist()), new Aresta("C", ponteBC = dist()));//B para F e C
    arestar(grafo.get(2), new Aresta("B", ponteBC), new Aresta("D", ponteCD = dist()));//C para B e D
    arestar(grafo.get(3), new Aresta("C", ponteCD), new Aresta("E", dist()));//para D
    arestar(grafo.get(4), new Aresta("G", dist()));//E aponta para G
    arestar(grafo.get(5), new Aresta("G", dist()));//F aponta para G que nãp aponta para ninguém
    
    //procurando o menor caminho, a origem é A na posição 0 e destino é G não posição 6, neste exemplo        
    Vertice.menorCaminho(grafo.get(0), grafo.get(6), grafo);            
}

//método para auxiliar o preenchimento
    private static void arestar(Vertice vertice, Aresta ... arestas){
    vertice.getArestas().addAll(Arrays.asList(arestas));
}

//para auxiliar na distância aleatória
    private static float dist(){
    return new Random().nextInt(25) + 5;
}

}


#16

ArrayList grafo = new ArrayList;


#17

A declaração que você fez esta com a sintaxe incorreta.
Se olhar a codificação vai ver não é como você fez.
O correto é:
ArrayList<Vertice> grafo = new ArrayList<>();