Hat da jemand eine Idee?

https://de.m.wikipedia.org/wiki/Hamiltonkreisproblem

S : Spieler
+ : Nicht überquerbare Blöcke
' ' : Bewegungsraum

+++++++++
+S      +
+++++++ +
+       +
+++++++++

Ich mache am besten mal ein Bsp meiner Map:

S : Spieler
+ : Nicht überquerbare blöcke
' ' : Bewegungsraum

++++++++++
+S  + +  +
+        +
+  +   +++
++++++++++

ALGORITHMUS eulerkreis:
    Übergabe: Graph, dargestellt mit einer Nachbarschaftstabelle
    kreisExistiert = True
    FÜR alle Knoten des Graphen:
        bestimme die Anzahl der Nachbarn des Knoten
        WENN diese Anzahl ungerade ist:
            kreisExistiert = False
    Rückgabe: kreisExistiert

Ein Beispiel, dass diese Methode bei mir nicht funktioniert:

+++++++ 
+S  + +
+     +
+++++++

Der Punkt unten rechts , hat 3 Nachbarn: Laut dem Algo ist es dem Spieler also nicht möglich alle Felder zu überqueren, ohne eins doppelt zu besuchen.Das heißt der Algo funtkioniert nur bei Karten, die "EinzelFeldWege" haben.

Hat noch jemand eine andere Idee?

Das bedeutet der Hamilton-Algo fällt raus...
Hat jemand noch eine Idee, wie man das lösen könnte?

Unabhängig gibt es in deinem Beispiel auch gar kein Pfad wie du suchst.

OK ne gibts doch. Ich dachte da wäre vom Start aus nur ein Feld rechts bis zur Wand.

EDIT: nur einmal habe ich überlesen. -.- Ob das trotzdem geht? *grübel*

Muss es effizient sein?
Ich würde es mit (speziellem) flood fill machen + dann über alles rüber gehen und prüfen.

EDIT: nur einmal habe ich überlesen. -.- Ob das trotzdem geht? *grübel*

Ich wollte schon gerade was sagen... Ich dachte auch erst das Problem wäre einfach aber die allgemeine Version davon ist NP-vollständig. Ich habe verschiedene Artikel gefunden die beweisen, dass das Problem auf speziellen Graphen (planar, kubisch) auch NP-vollständig ist. Ich gehe also mal davon aus, dass das Problem auf Rechteckgittern auch nicht gerade einfacher ist.

Soll geprüft werden ob jedes Feld für sich selbst, also einzeln, mit einem Pfad zum Startpunkt verbunden werden kann, oder ob es einen Pfad gibt, der über jedes Feld geht?

Mit jeweils der Einschränkung, dass jedes Feld nur einmal beschritten werden darf.
...Für ersteres ist diese Einschränkung ziemlich sinnlos oder?

Ja ok, dann ist es ein schwer lösbares, aber leicht überprüfbares Problem.

EDIT: In dem Fall wäre Backtracking die hirnlos Lösung.

Ich gehe also mal davon aus, dass das Problem auf Rechteckgittern auch nicht gerade einfacher ist.

Korrekt. Siehe Itai et al.: Hamilton Paths in Grid Graphs.
https://www.google.de/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CCAQFjAAahUKEwjllLTCnbHIAhUSmYgKHZxnDpg&url=http%3A%2F%2Fwww.cs.technion.ac.il%2F~itai%2Fpublications%2FAlgorithms%2FHamilton-paths.pdf&usg=AFQjCNE7MMmyG2_1LzOeqs8YcUHoDJa4fA&bvm=bv.104615367,d.eXY&cad=rja

Für solid grid graphs (keine löcher) gibt es wohl einen polynomiellen Algorithmus.

Meinst du mit Löchern sowas? :

+++++++++++
+S        +
+   +     +
+         +
+++++++++++

Das enthalten die Karten sehrwohl.

Aber Algorithmen finde ich keine brauchbaren dazu(Hab ca. ne Stunde gesucht).

Die größe der Karten ist auf 100x100 begrenzt(Dazwischen sind sie aber variabel groß, also zb. 40x45 oder 78x64).

Was ich schon habe:
-Begehbare Felder zählen
-Map aus .txt Datei einlesen
-Eine Flood Fill Methode, um zu prüfen, ob alle Felder zusammen hängen

Was ich noch brauche:
-Einen Pfad Generator , der auf keinen Block 2 mal geht, und alle möglichen Wege der Reihe nach durchgeht.

Wie schnell die Berechnung geht ist relativ egal.

Dann mach Backtracking. Gibt ja nur ca. N! Möglichkeiten zum testen. Bei N=100*100 und wenn du 10^12 Pfade pro Sekunde testest dauert es auch nur 2,8*10^35629 mal das aktuelle Alter des Universums und du bist auch schon fertig. Ich denke mit "relativ egal" meinst du irgendwas in der Größenordnung von maximal ein paar Tagen. Da ich noch keinen der Algorithmen getestet habe kann ich dir noch nicht sagen ob damit ein 100x100 Feld in absehbarer Zeit machbar ist. Da du ja keinen Algorithmus zu finden scheinst: Ich hatte hier doch schon einen verlinkt. Haste dir den mal angeschaut?

Haste dir den mal angeschaut?

Ja habe ich, werde daraus aber nicht schlau...

Gibts für das auch ein Codebeispiel?
Oder einen anderen Ansatz?

Ich kann ja nicht der einzige sein , der sowas versucht...

The algorithm is implemented in C++ and the program is demonstrated with several examples [Download].

ist das überhaupt erlaubt? Immerhin soll man das Ganze nach Möglichkeit selbst lösen.

das klingt aber alles sehr nach der ersten Aufgabe vom bundeswettbewerb-informatik

ist das überhaupt erlaubt? Immerhin soll man das Ganze nach Möglichkeit selbst lösen.

Danke für den Hinweis. Ich werde also schonmal nicht meinen Code hier posten. Allerdings spricht der TO von 100x100 Feldern und die bwinf Beispiele sind alle sehr klein. Die müsste man auch schnell mit Backtracking lösen können.