Eclipse Entfernung berechnen

[Shurik]

Guten Tag,
ich bin der Shurik und Studiere im 1sten Semester Informatik. Ich bräuchte für eine Projekt Aufgabe eine Starthilfe.
Aufgabe:
0. Stadt: 20/ 20
1. Stadt: 120/ 320
2. Stadt: 90/ 140
3. Stadt: 200/ 120
4. Stadt: 50/ 50

Ich habe diese Städte und muss daraus eine karte machen. Man fängt bei der Stadt 0 an und muss dann mit der Berechnung ( Satz des Pythagoras ) die nächste nahe liegende Stadt berechnen. Von der neuen Stadt aus muss ich dann wieder die nächst nahe liegende Stadt berechnen. So ergibt es am Ende eine Route von den Städten. Die Stadt 0 muss dann wenn man die nächste liegende Stadt zu 0 hat aus der Schleife rausgenommen werden damit man weiter kommt und nicht immer nur bei 2 Städten hängt.

Leider weiß ich nicht wie ich am besten Anfangen sollte und wie ich die erste Stadt dann aus der Schleife rausnehme.

Ich hoffe es ist verständlich genug und es kann mir jemand helfen.

Gruß,
Shurik

 

[Ark]

Na, dann zeig doch mal den Code, den du schon hast. 🙂

Ark

 

[TKausL]

So in etwa?

public class Stadt {
    public Stadt(int x, int y){
      this.x = x;
      this.y = y;
    }
    public int x;
    public int y
}


class Main {
    public void main(String[] args){
        Stadt[] staedte = new Stadt[5];
        staedte[0] = new Stadt(20,20);
        staedte[1] = new Stadt(120,320);
        staedte[2] = new Stadt(90,140);
        staedte[3] = new Stadt(200,120);
        staedte[4] = new Stadt(50,50);
	for(int i = 0; i < staedte.length - 1; i++){
	    for(int j = i + 1; j < staedte.length; j++){
		//Satz des Pythagoras zwischen staedte[i] und staedte[j]
	    }
	}

    }
}

 

[Shurik]

Also von dem Code habe ich bisher noch nichts zusammen bekommen. Ich habe aber die graphische Darstellung schonmal dazu gemacht in der dann die Punkte verbunden werden sollen.
Klasse Rundreise

package mypack;
import java.awt.*; import javax.swing.*;

public class Rundreise extends JPanel {
	private int WIDTH = 700; private int HEIGHT = 500; 
	private int[] stadt0 = new int[]{20,20};
	private int[] stadt1 = new int[]{120,320};
	private int[] stadt2 = new int[]{90,140};
	private int[] stadt3 = new int[]{200,120};
	private int[] stadt4 = new int[]{50,50};
	private int[] stadt5 = new int[]{300,300};
	private int[] stadt6 = new int[]{250,350};
	private int[] stadt7 = new int[]{130,90};
	private int[] stadt8 = new int[]{250,280};
	private int[] stadt9 = new int[]{180,180};
	
	public Rundreise () {
	
	JFrame f = new JFrame();
	f.setSize(WIDTH, HEIGHT);
	f.add(this);
	f.setVisible (true);
	}
	
	public void paintComponent(Graphics g) {
		g.fillOval(this.stadt0[0],this.stadt0[1], 10, 10);
		g.fillOval(this.stadt1[0],this.stadt1[1], 10, 10);
		g.fillOval(this.stadt2[0],this.stadt2[1], 10, 10);
		g.fillOval(this.stadt3[0],this.stadt3[1], 10, 10);
		g.fillOval(this.stadt4[0],this.stadt4[1], 10, 10);
		g.fillOval(this.stadt5[0],this.stadt5[1], 10, 10);
		g.fillOval(this.stadt6[0],this.stadt6[1], 10, 10);
		g.fillOval(this.stadt7[0],this.stadt7[1], 10, 10);
		g.fillOval(this.stadt8[0],this.stadt8[1], 10, 10);
		g.fillOval(this.stadt9[0],this.stadt9[1], 10, 10);
		
		g.drawString("0", 15, 20); 
		g.drawString("1", 115, 320); 
		g.drawString("2", 85, 140); 
		g.drawString("3", 195,120); 
		g.drawString("4", 45, 50); 
		g.drawString("5", 295, 300); 
		g.drawString("6", 245, 350); 
		g.drawString("7", 125, 90); 
		g.drawString("8", 245, 280); 
		g.drawString("9", 175, 180); 
		
		
	}
}

Hier meine main in der ich es aufrufe

package mypack;

public class Rundreise_main {
	
	public static void main(String[] args) {

		Rundreise reise = new Rundreise();
	}

}

Am Ende muss ich halt eine Karte haben wo alle die punkte verknüpft sind und immer nur der Punkt mit den an nächsten für Ihn.

 

[Djinndrache]

Du könntest mit einer for()-Schleife die Berechnung von Stadt X zu allen anderen Städten berechnen und die geringste Distanz ist dann dein Gewinner (also die Stadt, die am nächsten an Stadt X ist)

 

[Shurik]

Du könntest mit einer for()-Schleife die Berechnung von Stadt X zu allen anderen Städten berechnen und die geringste Distanz ist dann dein Gewinner (also die Stadt, die am nächsten an Stadt X ist)

ja das stimmt aber dann muss ja die erste Stadt aus der Berechnung raus, ich habe halt nicht nur 2 Städte. Wenn man nur von Punkt a zu Punkt b hätte wäre es um einige einfacher.

 

[Djinndrache]

ja das stimmt aber dann muss ja die erste Stadt aus der Berechnung raus, ich habe halt nicht nur 2 Städte. Wenn man nur von Punkt a zu Punkt b hätte wäre es um einige einfacher.

Wo ist das Problem? Von einer Stadt zu sich selbst ist die Distanz 0. Setz einfach als Bedingung, dass die geringste Distanz die du suchst > 0 sein soll.

 

[Shurik]

Wo ist das Problem? Von einer Stadt zu sich selbst ist die Distanz 0. Setz einfach als Bedingung, dass die geringste Distanz die du suchst > 0 sein soll.

Ich gehe von Stadt1 zu Stadt2 dann muss aber Stadt 1 raus, weil sonst die nächste Stadt zu Stadt2 wäre ja die Stadt1, das meine ich. Ich muss dann von Stadt2 die nächste liegende Stadt suchen die aber nicht Stadt1 sein darf da ich von dort ja komme.

 

[Shurik]

So in etwa?

public class Stadt {
    public Stadt(int x, int y){
      this.x = x;
      this.y = y;
    }
    public int x;
    public int y
}


class Main {
    public void main(String[] args){
        Stadt[] staedte = new Stadt[5];
        staedte[0] = new Stadt(20,20);
        staedte[1] = new Stadt(120,320);
        staedte[2] = new Stadt(90,140);
        staedte[3] = new Stadt(200,120);
        staedte[4] = new Stadt(50,50);
	for(int i = 0; i < staedte.length - 1; i++){
	    for(int j = i + 1; j < staedte.length; j++){
		//Satz des Pythagoras zwischen staedte[i] und staedte[j]
	    }
	}

    }
}

könntest du vllt noch eine Ausgabe dazu machen ich kann das irgendwie nirgends wo richtig einbauen in meinen Code den ich oben gepostet habe.
Danke aber so sieht mir das schon ganz gut aus.

 

[TKausL]

Ich weiß jetzt garnicht ob ich dich richtig verstanden habe.
Mit meinem Code würde einfach die Entfernung zwischen Jeder Stadt berechnet werden.

BTW: Ich hoffe du weißt selbst wie du eine Ausgabe auf der Console machst und du weißt auch, wie du den Pythagoras ausrechnest. Versuch selbst mal den Pythagoras aus staedte.x, staedte.y und staedte[j].x, staedte[j].y auszurechnen und auszugeben. Wenn du es nicht schaffst, Zeig was du versucht hast.

 

[Shurik]

Leider bin ich noch nicht sogut in Programmieren aber ich beschreibe erstmal den Algorithmus:
Ich berechne mit dem Satz des Pythagoras die Entfernungen von Stadt0 zu allen anderen, dann habe ich meine neue Stadt, dass ist die mit dem kürzestem weg zu Stadt0 ( zb Stadt 4). Dann gehe ich von Stadt4 aus und berechne zu allen übrigen Städten den Weg, aber die Stadt in der ich war darf da nicht mehr drin sein ( also ohne Stadt0) dann wäre die Stadt mit der kürzesten Distanz meine neue Stadt von der ich weiter rechnen muss, also so sieht die Theorie aus.

 

[TKausL]

Dann ist meiner der falsche Ansatz.

Ich würde eine ArrayList mit den Städten befüllen (außer die erste), dann von der ersten aus die Entfernungen zu allen Städten berechnen. Die Stadt mit der kürzesten Entfernung nimmst du dann aus der Liste raus und machst mit dieser genau das gleiche.

 

[Marco13]

Eine Methode wie

class Stadt {
...
    public double entfernungZu(Stadt andererStadt)
    {
         ...
    }
}

wäre vielleicht angebracht.

 

[pappawinni]

Also mal langsam...wenn du das..

Man fängt bei der Stadt 0 an und muss dann mit der Berechnung ( Satz des Pythagoras ) die nächste nahe liegende Stadt berechnen. Von der neuen Stadt aus muss ich dann wieder die nächst nahe liegende Stadt berechnen.

wörtlich nimmst.. dann pendelst du nur zwischen zwei Städten hin und her...weil, wenn die Stadt B die nächste Stadt von Stadt A ist, dann gilt das wohl umgekehrt auch.
Entfernungen zwischen den Städten zu ermitteln dürfte vermutlich mal so als erster Schritt richtig sein.

Der nächst Schritt müsste dann wohl ein Wegoptimierung sein. Das Optimierungsziel erscheint mir aber etwas fragwürdig.
Angenommen eine bereits besuchte Stadt würde aus der Betrachtung herausfallen, dann wäre immernoch die Frage was passieren soll, wenn zwei Städte die gleiche Entfernung von der aktuellen haben.

 

[Shurik]

Also mal langsam...wenn du das..



wörtlich nimmst.. dann pendelst du nur zwischen zwei Städten hin und her...weil, wenn die Stadt B die nächste Stadt von Stadt A ist, dann gilt das wohl umgekehrt auch.
Entfernungen zwischen den Städten zu ermitteln dürfte vermutlich mal so als erster Schritt richtig sein.

Der nächst Schritt müsste dann wohl ein Wegoptimierung sein. Das Optimierungsziel erscheint mir aber etwas fragwürdig.
Angenommen eine bereits besuchte Stadt würde aus der Betrachtung herausfallen, dann wäre immernoch die Frage was passieren soll, wenn zwei Städte die gleiche Entfernung von der aktuellen haben.

ja das habe ich auch oben geschrieben: Das die Stadt0 dann aus der schleife raus muss. Weil sonst hättest du recht und ich würde nur von Stadt0 zu Stadt4 gehen zb.

 

[test12345678]

...weil, wenn die Stadt B die nächste Stadt von Stadt A ist, dann gilt das wohl umgekehrt auch.

Nein, das ist ein Denkfehler:

Stadt1 ------- 10km -------> Stadt2 ------ 5km -----> Stadt3


ändert aber nichts daran, dass die besuchten städte nicht mehr berücksichtigt werden dürfen. 😉

 

[pappawinni]

Stimmt, muss nicht so sein, kann halt. Ebenso wie auftreten könnte, dass zwei Städte die gleiche Entfernung haben.