# Hilfe bei Labyrinth Programmierung.



## EJNunu (23. Nov 2014)

```
/******************************  Labyrinth.java  ******************************/

/**
 * Liest ein Labyrinth ein und berechnet mittels einem Backtracking
 * Algorithmus einen Weg durch dieses.
 * 
 * @author Christian Heiden
 * @author Lukas Kalbertodt
 */

import AlgoTools.IO;

public class Labyrinth {

	/** Freies Feld */
	private static final char FREI  = ' ';
	/** Mauer */
	private static final char MAUER = '#';
	/** Startfeld */
	private static final char START = 'S';
	/** Zielfeld */
	private static final char ZIEL  = 'Z';
	/** Besuchtes Feld */
	private static final char PFAD  = '-';


	/**
	 * Findet einen Weg durch das Labyrinth.
	 * Findet den Startpunkt und ruft findeZielRek mit dem Startpunkt auf.
	 * 
	 * @param lab Das Labyrinth
	 * @throws RuntimeException Wenn kein Startpunkt gefunden wurde
	 * @return Ob ein Weg gefunden wurde
	 */
	private static boolean findeZiel(char[][] lab) {
	
  
    // 





		return true;
	}


	/**
	 * Findet rekursiv einen Weg durch das Labyrinth
	 * 
	 * @param lab Das Labyrinth
	 * @param x X-Koordinate des Punktes bei dem man steht
	 * @param y Y-Koordinate des Punktes bei dem man steht
	 * @return Ob ein Weg gefunden wurde
	 */
	private static boolean findeZielRek(char[][] lab, int x, int y) {
	
  
  // 



		return true;
	}

	/**
	 * Zeigt das uebergebene Labyrinth auf dem Terminal an
	 * 
	 * @param lab Das anzuzeigende Labyrinth
	 */
	private static void druckeLabyrinth(char[][] lab) {




   // 



	}


	/**
	 * Liest das Labyrinth vom Terminal ein
	 * @return Das eingelesene Labyrinth
	 */
	private static char[][] leseEingabe() {
		int breite = 0, hoehe = 0;

		// Lese Breite ein
		do {
			breite = IO.readInt("Breite des Labyrinths: ");
		} while(breite <= 0);

		// Lese Hoehe ein
		do {
			hoehe = IO.readInt("Hoehe des Labyrinths: ");
		} while(hoehe <= 0);		

		// Lege Array an, welches ausgegeben wird
		char[][] out = new char[hoehe][breite];

		// Fuer jede Zeile
		for(int i = 0; i < hoehe; i++) {
			char[] zeile;

			// lies Zeile mit korrekter Anzahl von Buchstaben ein
			do {
				zeile = IO.readChars("Zeile " + i + " des Labyrinths: ");
			} while(zeile.length != breite);

			out[i] = zeile;
		}
		return out;
	}

	/**
	 * Liest Labyrinth ein und findet einen Weg von S nach Z
	 */
	public static void main(String[]args){
		
		// Lese Labyrinth ein
		char[][] lab = leseEingabe();

		// Gebe aus
		IO.println();
		IO.println("----- Original-Labyrinth: -----");
		druckeLabyrinth(lab);
		IO.println();

		boolean gefunden = findeZiel(lab);

		if(gefunden) {
			// Gebe aus
			IO.println("-----   Gefundener Weg:   -----");
			druckeLabyrinth(lab);
		} else {
			IO.println("Kein Weg zum Ziel gefunden!");
		}
	}
}
```







Kann mir bitte jemand das Programm vervollständigen?

VIelen Dank


----------



## JavaMeister (23. Nov 2014)

Vielleicht soltest du es in der Job-Börse posten.


----------



## Flown (24. Nov 2014)

Was lässt du dir das kosten? Oder willst du auch was mit Eigenleistung vollbringen?


----------



## Androbin (24. Nov 2014)

So was habe ich schon mal gemacht.
Ich tu's in den Anhang!


----------



## Flown (24. Nov 2014)

Also A* ist ein overkill für soetwas!


----------



## Ruzmanz (24. Nov 2014)

> So was habe ich schon mal gemacht.



Du hast den Code vergessen, wo du "so was" (=> Labyrinth mit *Rekursion *lösen) gemacht hast


----------



## Androbin (25. Nov 2014)

Ruzmanz hat gesagt.:


> Du hast den Code vergessen, wo du "so was" (=> Labyrinth mit *Rekursion *lösen) gemacht hast


Da steht "Backtracking", nicht "Rekursion"!


----------



## minzee (28. Nov 2014)

> Also A* ist ein overkill für soetwas!


Seh ich auch so. Da reicht doch ein Graphen-Breitendurchlauf, oder? Sobald ich den Zielknoten erreicht habe, stoppt der Algorithmus und liefert den Pfad vom Zielknoten zum Startknoten zurück.


----------



## Flown (28. Nov 2014)

Nö du benötigst einen simplen Backtracking Algorithmus, der dir das rechnet. A* gibt dir den kürzestesten/effizientesten Weg zurück.


----------



## Androbin (28. Nov 2014)

Flown hat gesagt.:


> Nö du benötigst einen simplen Backtracking Algorithmus, der dir das rechnet. A* gibt dir den kürzestesten/effizientesten Weg zurück.


Ja, aber den Backtracking Algorithmus habe ich da auch eingebaut!


----------

