C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Damenproblem
{
    //Sebastian Woll, 06.08.15

    class Program
    {
        static int n; //Feldlänge
        static int WievieleFelder; //Vermutete Menge der zu findenden Felder
        static string[][,] Felder = new string[WievieleFelder][,]; //Felder werden gespeichert
        static int CounterFelder = 0; // x-tes gefundenes Feld
        static int CounterRandom = 0; /* Seed des Zufallsgenerators für "mehr" Zufall 
                                       * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                                       * Mit diesem Counter werden bei n=8 immer 92 Lösungen gefunden,
                                       * ohne ihn erzeugt jeder Durchlauf ein anderes Ergebnis!                                        
                                       */
        static int CounterVergleichFALSE = 0; //Dient zur Terminierung des Programms nach zu vielen Fehlversuchen

        static void Main(string[] args)
        {
            Console.Write("\nWelche Länge sollen die Felder haben?\t");
            n = Convert.ToInt32(Console.ReadLine());
            WievieleFelder = n * n * n;
            Felder = new string[WievieleFelder][,];
            for (int i = 0; i < Felder.GetUpperBound(0); i++) //JaggedArray wird gefüllt
            {
                Felder[i] = new string[n, n];
                Felder[i][0, 0] = "."; //Der Punkt dient als Zeichen für "FREIES FELD"
            }
        //Feld generieren
        NeuesFeld:

            //Variablen deklarieren/zurücksetzen
            string[,] Feld = new string[n, n];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Feld[i, j] = ".";
                }
            }
            Random Zufall = new Random(CounterRandom);
            CounterRandom++;
            int x, y, CounterDame, CounterWuerfeln;
            CounterWuerfeln = 0;
            CounterDame = 0;
            //Variablen deklarieren/zurücksetztn ENDE

            //Feld füllen
            do
            {
            NeuWuerfeln:
                CounterWuerfeln++;
                x = Zufall.Next(n); //Dame bekommt zufällige Position
                y = Zufall.Next(n);
                if (Feld[x, y] == ".") // Ist die Position frei und nicht bedroht?
                {
                    Felderstreichen(x, y, Feld, CounterDame);
                    CounterDame++; //Nächste Dame
                }
                else
                {
                    if (CounterWuerfeln > n * n * 10) //Wuerfeln gegen endlos? / Position nicht lösbar?
                    {
                        break; //Abbruch bei zu langem Wuerfeln
                    }
                    else
                    {
                        goto NeuWuerfeln;
                    }
                }
            } while (CounterDame < n);
            //Feld füllen ENDE

            //Feld generieren ENDE

            if (CounterVergleichFALSE > 1000) //Wenn nach 1000 Treffern kein neues Feld gefunden wird, endet das Programm mit der Ausgabe des Zählers
            {
                Console.WriteLine("\nEs wurden {0} Felder gefunden.", CounterFelder);
            }
            else
            {
                //Damen alle da?
                if (CounterDame == n)
                {
                    //Feld schonmal gefunden?
                    if (ArraysVergleichen(Feld, Felder) == false) //Verlgeich funktioniert nicht
                    {
                        CounterVergleichFALSE = 0;
                        FeldAusgeben(Feld);
                        Felder[CounterFelder] = Feld;
                        CounterFelder++;
                        //FeldAusgeben(Feld);
                        if (CounterFelder < WievieleFelder - 1) //Weniger als WievieleFelder Felder wurden gefunden
                        {
                            //CounterFelder++;
                            goto NeuesFeld;
                        }
                        else
                        {
                            Console.WriteLine("Es wurden {0} Felder gefunden", CounterFelder);
                        }
                    }
                    else //Feld wurde schonmal gefunden
                    {
                        CounterVergleichFALSE++;
                        goto NeuesFeld;
                    }
                    //Feld schonmal gefunden? ENDE
                }
                else //Damen weniger als n
                {
                    goto NeuesFeld;
                }
                //Damen alle da? ENDE
            }

            Console.ReadLine();
        }//Ende Main


        //Felder streichen
        static void Felderstreichen(int x, int y, string[,] Feld, int CounterDame)
        {
            //Der Strich "-" bedeutet, dass das Feld bedroht ist.
            //Striche waagerecht und senkrecht
            for (int i = 0; i < n; i++)
            {
                Feld[x, i] = "-";
                Feld[i, y] = "-";
            }
            Feld[x, y] = "D";

            //Diagonale nach rechts unten
            for (int i = 1; (i < n - x) && (i < n - y); i++)
            {
                Feld[x + i, y + i] = "-";
            }
            //Diagonale nach links oben
            for (int i = 1; (i <= x) && (i <= y); i++)
            {

                Feld[x - i, y - i] = "-";

            }
            //Diagonale nach rechts oben
            for (int i = 1; (i <= x) && (i < n - y); i++)
            {
                Feld[x - i, y + i] = "-";
            }

            //Diagonale nach links unten
            for (int i = 1; (i < n - x) && (i <= y); i++)
            {
                Feld[x + i, y - i] = "-";
            }

        }//FelderstreichenEnde

        //FeldAusgeben
        static void FeldAusgeben(string[,] Feld)
        {
            Console.WriteLine();
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Console.Write(Feld[i, j] + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        } //FeldAusgeben ENDE


        //Arrays Vergleichen
        static bool ArraysVergleichen(string[,] NeuesFeld, string[][,] GefundeneFelder)
        {
            int CounterStimmt = 0;
            for (int i = 0; i < WievieleFelder - 1; i++)
            {
                CounterStimmt = 0;
                for (int j = 0; j < n; j++)
                {
                    for (int h = 0; h < n; h++)
                    {
                        if (NeuesFeld[j, h] == GefundeneFelder[i][j, h])
                        {
                            CounterStimmt++;
                        }
                    }
                }
                if (CounterStimmt == n * n)
                {
                    return true;
                }
            }
            return false;
        } //ArraysVergleichen ENDE

        //VERGLEICH FUNKTIONIERT NICHT, wurde durch ArrayVergleichen ersetzt
        // static bool IstFeldSchonVorhanden(string[,] NeuesFeld, string[][,] GefundeneFelder)
        //{
        //    for (int i = 0; i < WievieleFelder - 1; i++)
        //    {
        //        if (NeuesFeld.Equals(GefundeneFelder[i]))
        //        {
        //            FeldAusgeben(NeuesFeld);
        //            Console.WriteLine();
        //            FeldAusgeben(GefundeneFelder[i]);
        //            return true;
        //        }
        //    }
        //    return false;
        //}

        //Sebastian Woll, 06.08.15
    }
}