Springerproblem

Das Springerproblem ist ein kombinatorisches Problem, das darin besteht, für einen Springer auf einem leeren Schachbrett eine Route zu finden, auf der dieser jedes Feld genau einmal besucht. Eine mehrerer möglicher Verallgemeinerungen besteht darin, zweidimensionale Bretter beliebiger Größe n × m oder gar n-dimensionale Bretter zu verwenden. Eine Springertour heißt geschlossen, wenn das Endfeld des Springers einen Springerzug vom Startfeld entfernt ist. Anderenfalls heißt der Weg offen (wie im Diagramm).

Das Springerproblem ist auch unter dem Namen Rösselsprung bekannt. Letzterer Ausdruck bezeichnet allerdings häufiger das Rösselsprungrätsel, bei dem Buchstaben oder Silben in den Feldern des Brettes eingetragen sind, die in der richtigen Reihenfolge durch eine Springertour besucht, einen Lösungssatz oder ein Lösungswort ergeben. Es sei ferner angemerkt, dass das Springerproblem etwas völlig anderes als das Damenproblem ist, doch haben sich die beiden Bezeichnungen historisch eingebürgert.

Das Problem findet sich in einem Sanskrit-Gedicht von Rudrata aus dem 9. Jahrhundert.^[1] Im Westen wird es in einem Codex des 14. Jahrhunderts der Pariser Nationalbibliothek erwähnt.^[2] Abraham de Moivre und Pierre Rémond de Montmort gaben Anfang des 18. Jahrhunderts Lösungen an. Der Schweizer Mathematiker Leonhard Euler behandelte das Springerproblem 1759 mathematisch. Seitdem haben sich viele weitere Mathematiker (unter ihnen Legendre und Vandermonde) und unzählige Hobby-Tüftler mit der Materie beschäftigt.

In den 1950er Jahren entwickelte der Apotheker Gerard D’Hooghe einen Automaten, der eine Springerrundreise von einem beliebig vorgegebenen Ausgangsfeld demonstriert. Die Grundlagen für diesen Automaten stellte er 1962 in dem Buch Les Secrets du Cavalier, Le Problème d’Euler dar. Sein sogenannter t’Zeepaard wurde 1960 während der Schacholympiade in Leipzig öffentlich gezeigt.

Das Springerproblem ist ein Spezialfall des Hamiltonpfadproblems, eines bekannten Problems der Graphentheorie, bei dem in einem Graphen alle Knoten genau einmal besucht werden müssen. Wenn von dem letzten Feld der Zugfolge das erste Feld erreicht werden kann, hat man einen Hamiltonkreis gefunden. Das Hamiltonpfadproblem ist NP-vollständig, ein effizienter Lösungsalgorithmus ist also nicht bekannt und existiert, wie allgemein vermutet wird, auch nicht. Dagegen existieren für das Springerproblem effiziente Algorithmen, die unten vorgestellt werden.

Ein erster Ansatz für einen Algorithmus besteht darin, ein einfaches Backtracking-Verfahren anzuwenden. Hierbei wählt man eine willkürliche Route und nimmt, wenn man in einer Sackgasse angelangt ist, den jeweils letzten Zug zurück und wählt stattdessen einen alternativen Zug aus. Dieser Algorithmus findet auf jeden Fall eine Lösung, sofern eine existiert, er ist jedoch sehr langsam. Auf größeren Brettern kann ein Mensch durch geschicktes Ausprobieren innerhalb viel kürzerer Zeit eine Lösung finden, als dass der einfache Backtracking-Algorithmus zum Ziel kommt.

Das folgende Computerprogramm in der Programmiersprache C++ findet eine Lösung des Springerproblem mit Hilfe eines rekursiven Algorithmus, der Backtracking verwendet. Wenn eine gefundene Tour alle n 2 = 8 2 = 64 {\displaystyle n^{2}=8^{2}=64} Felder des Schachbretts durchläuft, wird die Lösung ausgegeben und das Programm beendet.^[3]

#include <iostream>
#include <sstream>
using namespace std;

const int n = 8; // Konstante für die Anzahl der Felder pro Seite

// Gibt die Züge der Springertour auf der Konsole aus
string knightsTourToString(int knightsTour[n][n])
{
    stringstream text;
    int weight = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            text << knightsTour[i][j] << "\t";
        }
        text << endl;
    }
    return text.str(); // Typumwandlung von stringstream nach string
}

// Diese rekursive Methode bestimmt eine Springertour und gibt true zurück, wenn gefunden, sonst false
bool getKnightsTourRecursive(int x, int y, int moveNumber, int knightsTour[n][n], int xMove[n], int yMove[n])
{
    if (moveNumber == n * n) // Wenn alle Felder besucht sind, wird true zurückgegeben
    {
        return true;
    }
    // Prüft die möglichen Züge des Springers für das aktuelle Feld mit den Koordinaten x, y
    for (int i = 0; i < 8; i++)
    {
        // Bestimmt die Koordinaten des nächsten Felds
        int nextX = x + xMove[i];
        int nextY = y + yMove[i];
        if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < n && knightsTour[nextX][nextY] == -1) // Wenn das nächste Feld innerhalb des Schachbretts liegt und noch nicht besucht wurde
        {
            knightsTour[nextX][nextY] = moveNumber; // Setzt die Zugnummer für das nächste Feld
            if (getKnightsTourRecursive(nextX, nextY, moveNumber + 1, knightsTour, xMove, yMove)) // Rekursiver Aufruf der Methode für den nächsten Zug
            {
                return true; // Wenn Springertour gefunden
            }
            else
            {
                knightsTour[nextX][nextY] = -1; // Wenn keine Springertour gefunden wurde, wird der Zug rückgängig gemacht
            }
        }
    }
    return false; // Wenn keine Springertour gefunden
}

// Diese Methode bestimmt eine Springertour mithilfe von Backtracking und gibt true zurück, wenn vorhanden, sonst false
bool getKnightsTour(int knightsTour[n][n])
{
    // Initialisiert die Felder des Schachbretts
    for (int i = 0; i < n; i++) // Diese beiden for-Schleifen durchlaufen alle Felder des Schachbretts
    {
        for (int j = 0; j < n; j++)
        {
            knightsTour[i][j] = -1;
        }
    }
    // Diese Arrays definieren die möglichen Züge des Springers
    int xMoves[8] = { 2, 1, -1, -2, -2, -1, 1, 2 }; // Array für die Änderung der x-Koordinate
    int yMoves[8] = { 1, 2, 2, 1, -1, -2, -2, -1 }; // Array für die Änderung der y-Koordinate
    knightsTour[0][0] = 0; // Initialisiert das Startfeld links oben
    return getKnightsTourRecursive(0, 0, 1, knightsTour, xMoves, yMoves); // Aufruf der Methode
}

// Hauptmethode, die das Programm ausführt
int main()
{
    int knightsTour[n][n]; // Deklariert ein zweidimensionales Array für die Felder des Schachbretts
    if (getKnightsTour(knightsTour)) // Aufruf der Methode
    {
        cout << knightsTourToString(knightsTour); // Ausgabe auf der Konsole
    }
    else
    {
        cout << "Es gibt keine Springertour." << endl; // Ausgabe auf der Konsole
    }
}

Im Jahr 1823 schlug H. C. von Warnsdorf eine heuristische Regel vor, die das Finden einer Lösung stark vereinfacht. Nach der Warnsdorfregel zieht der Springer immer auf das Feld, von dem aus er für seinen nächsten Zug am wenigsten freie (d. h. noch nicht besuchte) Felder zur Verfügung hat. Diese Regel ist unmittelbar einleuchtend; sie verhindert beispielsweise, dass eines der beiden Felder, die der Springer von einer Ecke aus erreichen kann, frühzeitig besucht wird, so dass er später nicht mehr aus der Ecke entkommen könnte. Die Warnsdorfsregel gibt keine Anweisung, was zu tun ist, wenn es mehrere Felder gibt, von denen es gleich wenige im nächsten Zug erreichbare Felder gibt.

Die Warnsdorfregel kann, auch wenn eine Lösung existiert, nicht garantieren, dass diese gefunden wird, und in der Tat gerät der Springer für große Bretter zunehmend oft in eine Sackgasse. Selbst auf einem Schachbrett (n = 8) kann der Algorithmus scheitern, wenn man unter mehreren möglichen Alternativen die falschen auswählt, dies ist allerdings sehr unwahrscheinlich.

Hier ansetzend wurden verbesserte Heuristiken entwickelt, unter anderem ein Algorithmus von Squirrel, der recht komplizierte Entscheidungsregeln für den Fall mehrerer nach der Warnsdorfregel gleichwertiger Alternativen angibt, jedoch anscheinend für alle Bretter größer als n = 75 in linearer Zeit eine Lösung findet (der formale Korrektheitsbeweis ist bisher nur für n = 7 mod 8 geführt). Die Verbindung von Warnsdorfregel und Backtracking-Verfahren ist möglich, führt aber bei großen Brettern wiederum zu exponentiell anwachsender Laufzeit.

Im Rahmen einer Arbeit für Jugend forscht entwickelte eine Gruppe verschiedene Algorithmen, mit denen für beliebig große n × n {\displaystyle n\times n} Felder eine Lösung in einer Laufzeitkomplexität von O ( n 2 ) {\displaystyle {\mathcal {O}}(n^{2})} gefunden werden kann. In ihrem 1994 veröffentlichten Aufsatz^[4] stellten sie ein Verfahren vor (das Teile-und-herrsche-Verfahren), bei dem sie beliebige Schachbretter in kleinere Teilrechtecke mit Größen von 5 × 5 bis 9 × 9 aufteilen, für die spezielle Lösungen existieren.

Für jedes m × n {\displaystyle m\times n} Brett, mit m ≤ n {\displaystyle m\leq n} , n > 1 {\displaystyle n>1} , gibt es eine geschlossene Springertour, es sei denn, einer der folgenden drei Fälle liegt vor:

1. m {\displaystyle m} und n {\displaystyle n} sind beide ungerade

2. m = 1 , 2 , 4 {\displaystyle m=1,2,4}

3. m = 3 {\displaystyle m=3} und n = 4 , 6 , 8 {\displaystyle n=4,6,8}

Ein Beweis lässt sich anhand der in der oben genannten Jugend-forscht-Arbeit dargestellten Algorithmen herleiten.^[5] Unter den genannten Bedingungen können beliebige Start- und Zielfelder gewählt werden, also auch solche, bei denen von dem Zielfeld wieder auf das Startfeld gesprungen und damit die Springertour geschlossen werden kann.

Man stelle sich vor, die Felder seien schachbrettartig schwarzweiß gefärbt. Start- und Endfeld müssen bei einem geschlossenen Weg verschiedene Farben haben. Da der Springer nach jedem Zug seine Feldfarbe wechselt, muss er auf seinem Weg genauso viel weiße wie schwarze Felder überschreiten, also eine gerade Zahl an Feldern.

Ist m = 1 {\displaystyle m=1} oder m = 2 {\displaystyle m=2} , so kann der Springer offensichtlich nicht jedes Feld erreichen (es sei denn im trivialen Fall des 1 × 1-Bretts).

Ist m = 4 {\displaystyle m=4} , so sei A 1 {\displaystyle A_{1}} die Menge der weißen Felder, B 1 {\displaystyle B_{1}} die Menge der schwarzen Felder, A 2 {\displaystyle A_{2}} die Menge der Randfelder an den beiden gegenüberliegenden längeren Brettkanten und B 2 {\displaystyle B_{2}} die Menge aller Felder, die nicht zu A 2 {\displaystyle A_{2}} gehörten, sprich B 2 = ∁ A 2 {\displaystyle B_{2}=\!^{\complement }A_{2}} . B 2 {\displaystyle B_{2}} hat gleich viele Elemente wie A 2 {\displaystyle A_{2}} .

In jedem Zug ändert der Springer die Feldfarbe und die Feldart zwischen A 2 {\displaystyle A_{2}} und B 2 {\displaystyle B_{2}} . Letzteres folgt aus folgender Überlegung: Von einem Randfeld (Menge A 2 {\displaystyle A_{2}} ) kann der Springer nur auf ein Feld in der Mitte gelangen (Menge B 2 {\displaystyle B_{2}} ). Würde der Springer nun einen Zug innerhalb von B 2 {\displaystyle B_{2}} ausführen (was möglich ist), würde er mehr Felder von B 2 {\displaystyle B_{2}} besuchen als von A 2 {\displaystyle A_{2}} , was zu keiner Lösung führen kann, weil die beiden Mengen gleich viele Felder umfassen.

Ohne Einschränkung ist das Anfangsfeld ein Element aus A 1 {\displaystyle A_{1}} und A 2 {\displaystyle A_{2}} . Vertausche hierfür notfalls die Rollen von A 1 {\displaystyle A_{1}} und B 1 {\displaystyle B_{1}} und die Rollen von A 2 {\displaystyle A_{2}} und B 2 {\displaystyle B_{2}} .

Im nächsten Zug ist die Feldfarbe Element aus B 1 {\displaystyle B_{1}} und B 2 {\displaystyle B_{2}} , dann wieder aus A 1 {\displaystyle A_{1}} und A 2 {\displaystyle A_{2}} und so weiter.

Dies zeigt zum einen, dass A 1 {\displaystyle A_{1}} die gleichen Elemente wie A 2 {\displaystyle A_{2}} hat, und zum anderen, dass B 1 {\displaystyle B_{1}} die gleichen Elemente wie B 2 {\displaystyle B_{2}} hat, somit A 1 = A 2 {\displaystyle A_{1}=A_{2}} und B 1 = B 2 {\displaystyle B_{1}=B_{2}} , was offensichtlich nicht stimmt.

Auf den Brettern 3 × 4, 3 × 6 und 3 × 8 lässt sich kein geschlossener Weg finden.

Wege für die Brettgrößen 3 × 10, 3 × 12, 3 × 14 usw. sind möglich, wobei sich das Lösungsmuster wiederholt.

Die Anzahl der Lösungen für ein n × n {\displaystyle n\times n} -Schachbrett steigt schneller als exponentiell mit n {\displaystyle n} . Für n ≤ 8 {\displaystyle n\leq 8} ist die Anzahl der möglichen Touren bekannt:^[6][7]

Auf Brettern mit einer ungeraden Anzahl Feldern gibt es aus Paritätsgründen keine geschlossene Tour (siehe 1. Fall von Schwenksches Theorem).

• Längster kreuzungsfreier Springerpfad
• Damenproblem

• Douglas Squirrel, Paul Cull: A Warnsdorff-Rule Algorithm for Knight’s Tours on Square Chessboards. Oregon State REU Program, 1996. (Beschreibung einer Erweiterung der Warnsdorfregel, die das Springerproblem in linearer Zeit löst)
• Allen J. Schwenk: Which Rectangular Chessboards Have a Knight’s Tour?, Mathematics Magazine 64 (1991) p. 325-332. doi:10.1080/0025570X.1991.11977627

Commons: Knight's Tours – Sammlung von Bildern, Videos und Audiodateien

• Ausführliche Seite mit einer optimalen Lösung
• Seite zur Warnsdorfregel, inklusive Applet zum Ausprobieren (Memento vom 2. August 2012 im Internet Archive)

1. ↑ Bill Wall Earliest chess books and references (Memento vom 21. Januar 2012 im Internet Archive)
2. ↑ Wilhelm Ahrens Mathematische Unterhaltungen und Spiele, Teubner 1901, S. 165. Er zitiert A. von der Linde Geschichte und Literatur des Schachspiels, Berlin 1874, Band 2, S. 101. Siehe auch W. W. Rouse Ball Mathematical recreations and essays, 4. Auflage. Macmillan 1905, S. 158ff, Online bei Gutenberg
3. ↑ GeeksforGeeks: The Knight’s tour problem | Backtracking-1
4. ↑ Axel Conrad, Tanja Hindrichs, Hussein Morsy, Ingo Wegener: Solution of the Knight’s Hamiltonian Path Problem on Chessboards. Discrete Applied Mathematics, Volume 50, Issue 2, May 1994, Pages 125-134.
5. ↑ Axel Conrad: Eine kurze Reise durch die Welt des Springers. In: axel-conrad.de. Archiviert vom Original (nicht mehr online verfügbar) am 22. Juli 2012; abgerufen am 1. September 2024. 
6. ↑ Folge A165134 in OEIS
7. ↑ Wolfram MathWorld: Knight Graph