Backtracking

abfdx

Aktives Mitglied
Hallo!
Ich bin dabei, einen einfachen Backtracking-Algorithmus zu programmieren. Hab das Programm auch schon relativ weit, aber irgendwo steckt ein Fehler drin.
Hoffe auf schnelle Hilfe ^^
Java:
import java.util.ArrayList;

public class MainClass {
  
    public static ArrayList<Muenze> MuenzeList = new ArrayList<Muenze>();
  
    public static ArrayList<MainClass> Geld = new ArrayList<MainClass>();
  


    public static void main(String[] args) {

        MuenzeList.add (new Muenze (1, 3));
        MuenzeList.add(new Muenze (9,5));
        MuenzeList.add (new Muenze (1, 6));
        MuenzeList.add(new Muenze (3,2));
        Backtracking();
    }
    public static void Backtracking() { //2^n Möglichkeiten
        int InhaltSack = 0;
        int kapazitaetSack;
        int GeldSack = 0;
        kapazitaetSack = 5;
        for (int n = 0; n <= MuenzeList.size(); n++) {
            for (int i = n; i < MuenzeList.size(); i++) {
                    if (MuenzeList.get(i).getGewicht() <= (kapazitaetSack - InhaltSack)) {
                        InhaltSack += MuenzeList.get(i).getGewicht();
                        GeldSack += MuenzeList.get(i).getWert();
                    }
            }
            System.out.print(InhaltSack +", ");
            System.out.println(GeldSack);
        }  
    }
}
Das ist die MainClass
und jetzt noch die Muenze Klasse:
Java:
public class Muenze {

   private int wert;
   private int gewicht;
   
   public Muenze() {
       super();
   }
   public Muenze(int value, int size) {
       super();
       this.wert = value;
       this.gewicht = size;
   }
   public int getWert() {
       return wert;
   }

   public int getGewicht() {
       return gewicht;
   }

   @Override
   public String toString() {
       return "(" + wert + "," + gewicht  + ")";
   }
   
   
}
 
Zuletzt bearbeitet:

abfdx

Aktives Mitglied
Also ich hab Geld und möchte möglichst viel Geld (vom Wert gesehen) in einen Sack packen, der aber nur beschränkt viel Gewicht tragen kann.
 

eno_x3

Mitglied
Verstehe ich es richtig, dass du durch "Bruteforce", also ausprobieren aller Möglichkeiten die beste Option herausfinden willst?
Du musst in der ersten for Schleife die Variablen wieder auf 0 setzen, ansonsten bleibt das Gewicht ja immer schon bei 5 und der If Block wird nicht ausgeführt.
Java:
for(int n = 0; n<= MuenzeList.size(); n++){
    InhaltSack = 0;
    GeldSack = 0;

PS: Du probierst so nicht alle Möglichkeiten aus.
 

abfdx

Aktives Mitglied
Okay, nächstes Problem:
Ich will jetzt nicht so dumm wirken, aber warum funktioniert es bei den Werten:
5|3
2|6
1|3
4|5
und einer Kapazität von 10 nicht?
Man kann dann doch 9|8 erreichen, das Programm kommt nur auf 7|9...

(leicht veränderter aktueller Code):
Java:
import java.util.ArrayList;

public class MainClass {
   
    public static ArrayList<Muenze> MuenzeList = new ArrayList<Muenze>();
   
    public static void main(String[] args) { //man kann doch auf 9|8 kommen
        MuenzeList.add (new Muenze (5, 3));
        MuenzeList.add(new Muenze (2,6));
        MuenzeList.add (new Muenze (1, 3));
        MuenzeList.add(new Muenze (4,5));
        Backtracking();
    }
    public static void Backtracking() { //2^n Möglichkeiten
        int GeldSack = 0;
        int vorherGeldsack = GeldSack;
        int kapazitaetSack;
        kapazitaetSack = 10;
        for (int n = 0; n < MuenzeList.size(); n++) {
            System.out.println("Neuer Anfang");
            GeldSack = 0;
            int InhaltSack = 0;
            for (int i = n; i < MuenzeList.size(); i++) {
                    if (MuenzeList.get(i).getGewicht() <= (kapazitaetSack - InhaltSack)) {

                        InhaltSack += MuenzeList.get(i).getGewicht();
                        GeldSack += MuenzeList.get(i).getWert();
                        int vorherGeldSack = GeldSack;
                    }
                    if (GeldSack > vorherGeldsack) {
                        System.out.println("Neuer Wert" + MuenzeList.get(i));
                        System.out.print(GeldSack +", ");
                        System.out.println(InhaltSack);   
                        vorherGeldsack = GeldSack;
                    }
            }
        }
    }
}
 
Zuletzt bearbeitet:

abfdx

Aktives Mitglied
Okay, nächstes Problem:
Ich will jetzt nicht so dumm wirken, aber warum funktioniert es bei den Werten:
5|3
2|6
1|3
4|5
und einer Kapazität von 10 nicht?
Man kann dann doch 9|8 erreichen, das Programm kommt nur auf 7|9...

(leicht veränderter aktueller Code):
Java:
import java.util.ArrayList;

public class MainClass {
  
    public static ArrayList<Muenze> MuenzeList = new ArrayList<Muenze>();
  
    public static void main(String[] args) { //man kann doch auf 9|8 kommen
        MuenzeList.add (new Muenze (5, 3));
        MuenzeList.add(new Muenze (2,6));
        MuenzeList.add (new Muenze (1, 3));
        MuenzeList.add(new Muenze (4,5));
        Backtracking();
    }
    public static void Backtracking() { //2^n Möglichkeiten
        int GeldSack = 0;
        int vorherGeldsack = GeldSack;
        int kapazitaetSack;
        kapazitaetSack = 10;
        for (int n = 0; n < MuenzeList.size(); n++) {
            System.out.println("Neuer Anfang");
            GeldSack = 0;
            int InhaltSack = 0;
            for (int i = n; i < MuenzeList.size(); i++) {
                    if (MuenzeList.get(i).getGewicht() <= (kapazitaetSack - InhaltSack)) {

                        InhaltSack += MuenzeList.get(i).getGewicht();
                        GeldSack += MuenzeList.get(i).getWert();
                        int vorherGeldSack = GeldSack;
                    }
                    if (GeldSack > vorherGeldsack) {
                        System.out.println("Neuer Wert" + MuenzeList.get(i));
                        System.out.print(GeldSack +", ");
                        System.out.println(InhaltSack);  
                        vorherGeldsack = GeldSack;
                    }
            }
        }
    }
}
Hilfe! Ich bin zu blöd, ich versteh es einfach nicht... :(:confused:
 

abfdx

Aktives Mitglied
@fhoffmann ja das hab ich auch bemerkt. Hab jetzt hinzugefügt, dass wenn die 1. if-Prüfung falsch ist, er die letzte Zahl wieder "aus dem Sack herausnimmt". Wie krieg ich das denn hin, dass er (wenn nötig) mehr als eine Zahl wieder herausnimmt? Weil bei meinen Zahlen beispielsweise reicht es ja nicht aus, einen Wert wieder zurückzunehmen...
 

abfdx

Aktives Mitglied
Kann mir irgendwer noch helfen? Ich hab das komplette Internet auf den Kopf gestellt, aber komme keinen Schritt weiter. Hat vielleicht jemand einen Tipp oder Pseudocode oder irgendwas? Bin gerade echt am verzweifeln :/
 

abfdx

Aktives Mitglied
@fhoffmann warum soll es mit den for-Schleifen denn nicht funktionieren? Ich gehe damit (theoretisch zumindest) alle Möglichkeiten, die Sinn ergeben, durch. Am Ende gebe ich dann die beste dieser Möglichkeiten aus. Nach Rucksackproblem oder auch Knapsackproblem hab ich natürlich schon gesucht, aber trotzdem Danke für den Tipp! Noch andere Lösungsvorschläge? :(
 

mihe7

Top Contributor
Aktuell nimmst Du eine Liste von Münzen, teilst diese in jeder Iteration in zwei Listen und lässt die erste jeweils unter den Tisch fallen. D. h. wenn die n-te Münze im Sack sein soll, muss zwangsweise auch (n+1)-te Münze im Sack sein. Damit hast Du die Möglichkeit, n-te Münze im Sack, (n+1)-te Münze nicht im Sack ausgeschlossen.
 

abfdx

Aktives Mitglied
Ehm.. was?
Kannst du wohl bitte bitte den Codeausschnitt dazu tun (im besten Falle natürlich meinen und was ich verändern soll, das würde mir echt helfen)?
Wie gesagt, das Zeug treibt mich echt noch in den Wahnsinn ;D
 

mihe7

Top Contributor
Ich habe nur von Deinem Code geschrieben:
Java:
      for (int n = 0; n <= MuenzeList.size(); n++) {
            for (int i = n; i < MuenzeList.size(); i++) {
                 // irgendwas mit MuenzeListe.get(i)
(BTW: ich sehe gerade: <= MuenzeListe.size() -> das "=" kannst Du Dir sparen)

Du teilst die MuenzeListe in zwei Teillisten auf, nämlich von 0 bis (n-1) und von n bis MuenzeListe.size()-1. Du betrachtest anschließend immer nur die zweite Teilliste und damit immer nur Münzen, die nacheinander in der Liste stehen.

Code:
             0123456789
n=0:         |---------
im Sack:     --------->
n=1:         ||--------
im Sack:      -------->
n=2:         -||-------
im Sack:       ------->
n=3:         --||------
im Sack:        ------>
n=4:         ---||-----
im Sack:         ----->
...

Es fehlt z. B.
im Sack      -  -  - -

Modelliere das Problem als Baum.

EDIT: Beispiel ergänzt.
 
Zuletzt bearbeitet:

abfdx

Aktives Mitglied
@mihe7 okay das Problem hab ich jetzt schonmal verstanden, aber wie muss ich das ganze jetzt verändern? Und wie soll dieser Baum dann aussehen?
Danke euch allen auf jeden Fall schonmal für eure Hilfe, hoffe ihr bringt mich weiterhin so vorwärts :D
 

abfdx

Aktives Mitglied
Man könnte natürlich den Quotienten bilden und die danach sortieren...
Aber bei den Werten (5|5), 3x (1,8|2) und einer Kapazität von 6 würde er da auch schon wieder vor ne Wand laufen.. :oops::(
EDIT: Die Werte sind nur ein Beispiel. Aber damit kann man es sich einfach besser vorstellen (finde ich)
 
Zuletzt bearbeitet:

abfdx

Aktives Mitglied
Man könnte natürlich den Quotienten bilden und die danach sortieren...
Aber bei den Werten (5|5), 3x (1,8|2) und einer Kapazität von 6 würde er da auch schon wieder vor ne Wand laufen.. :oops::(
EDIT: Die Werte sind nur ein Beispiel. Aber damit kann man es sich einfach besser vorstellen (finde ich)
wobei, ...
kann ich nicht mit den verschachtelten for-Schleifen einfach den Startpunkt immer höher setzen, bis ich bei n beginne? irgendwie?
 

abfdx

Aktives Mitglied
Java:
   public static void main(String[] args) {

        MuenzeList.add (new Muenze (5, 3, (float) 1.6666666666666));
        MuenzeList.add(new Muenze (2,6,(float) (2.00/6.00)));
        MuenzeList.add (new Muenze (1, 3,(float) (1.00/3.00)));
        MuenzeList.add(new Muenze (4,5,(float) (4.00/5.00)));
        System.out.println(MuenzeList.get(0));
    }


Warum ist die Ausgabe dabei immer 5, 3, 0.0 ???
Hab in der anderen Klasse auch alles auf die float angepasst, aber kriege immer nur 0.0 zurück
 

abfdx

Aktives Mitglied
Komplette Muenze-Klasse:
Java:
public class Muenze {

    private int wert;
    private int gewicht;
    private float quotient;
  
    public Muenze() {
        super();
    }
    public Muenze(int value, int size, float quotient) {
        super();
        this.wert = value;
        this.gewicht = size;

    }
    public int getWert() {
        return wert;
    }

    public int getGewicht() {
        return gewicht;
    }
    public float getQuotient() {
        return (float) quotient;
    }

    @Override
    public String toString() {
        return "(" + wert + "," + gewicht + "," + quotient + ")";
    }
  
  
}
 

abfdx

Aktives Mitglied
Komplette Main-Klasse:
Java:
public class Muenze {

    private int wert;
    private int gewicht;
    private float quotient;
   
    public Muenze() {
        super();
    }
    public Muenze(int value, int size, float quotient) {
        super();
        this.wert = value;
        this.gewicht = size;
    }
    public int getWert() {
        return wert;
    }

    public int getGewicht() {
        return gewicht;
    }
    public float getQuotient() {
        return (float) quotient;
    }

    @Override
    public String toString() {
        return "(" + wert + "," + gewicht + "," + quotient + ")";
    }
   
   
}
 

abfdx

Aktives Mitglied
Okay, es ist noch ETWAS unübersichtlich, aber vielleicht könnt ihr trotzdem schonmal drüber gucken?

MainClass:
Java:
import java.util.ArrayList;

public class MainClass {
    public static ArrayList<Muenze> MuenzeList = new ArrayList<Muenze>();
    public static ArrayList<Geld> GeldList = new ArrayList<Geld>();


    public static void main(String[] args) {

        MuenzeList.add (new Muenze (50, 50, (float) 50/50));
        MuenzeList.add(new Muenze (18,20,(float) 18/20));
        MuenzeList.add(new Muenze (18,20,(float) 18/20));
        MuenzeList.add(new Muenze (18,20,(float) 18/20));
        sort(3);
        Backtracking();
        sortEnde(1);
     //   System.out.println(GeldList);
    }
   
    public static void Anzeigen() { //Werte ungeordnet (ohne irgendwas zu machen) anzeigen
        System.out.println(MuenzeList);
    }
    public static void Backtracking() {
        float InhaltSack = (float) 0.00;
        float kapazitaetSack;
        double GeldSack = 0;
        kapazitaetSack = (float) 60.00;
        for (int n = 0; n <= MuenzeList.size(); n++) {
            InhaltSack = 0;
            GeldSack = 0;
            for (int i = n; i < MuenzeList.size(); i++) {
                    if (MuenzeList.get(i).getGewicht() <= (kapazitaetSack - InhaltSack)) {
                        InhaltSack += MuenzeList.get(i).getGewicht();
                        GeldSack += MuenzeList.get(i).getWert();
                       
                    }
            }
        //    System.out.print(GeldSack +", ");
          //  System.out.println(InhaltSack);
            GeldList.add(new Geld ((float) GeldSack, InhaltSack));
        } 
    }
    public static void sort(int kriterium) { //sortierMethode
          for (int j = 0; (j<MuenzeList.size()-1); j++) {
              for (int i = 0; (i < MuenzeList.size()-1); i++ ) {
                  Muenze m = MuenzeList.get(i+1);
                  Muenze m2 = MuenzeList.get(i);
                  if (m.istKleiner(m2 , kriterium)) {
                      MuenzeList.set(i+1, MuenzeList.get(i));
                      MuenzeList.set(i, m);

                  }
              }
          }
         
        //  System.out.println(MuenzeList);
    }
    public static void sortEnde(int kriterium) { //sortierMethode
          for (int j = 0; (j<GeldList.size()-1); j++) {
              for (int i = 0; (i < GeldList.size()-1); i++ ) {
                  Geld g = GeldList.get(i+1);
                  Geld g2 = GeldList.get(i);
                  if (g.istKleiner(g2 , kriterium)) {
                      GeldList.set(i+1, GeldList.get(i));
                      GeldList.set(i, g);
                  }
              }
          }
          System.out.println(GeldList.get(0));
    }
}

Muenze-Class:
Java:
public class Muenze {

    private int wert;
    private int gewicht;
    private float quotient;
   
    public Muenze() {
        super();
    }
    public Muenze(int value, int size, float quotient) {
        super();
        this.wert = value;
        this.gewicht = size;
        this.quotient = quotient;
    }
    public int getWert() {
        return wert;
    }

    public int getGewicht() {
        return gewicht;
    }
    public float getQuotient() {
        return (float) quotient;
    }
    public boolean istKleiner (Muenze m, int index) {
        if (index == 1) {
            return this.wert > m.getWert();
        } if (index == 2) {
            return this.gewicht > m.getGewicht();
        } else {
            return (this.quotient > m.getQuotient());
        }
    }
   

    @Override
    public String toString() {
        return "(" + wert + "," + gewicht + "," + quotient + ")";
    }
   
   
}
und Geld-Class:
Java:
public class Geld {

    private float GeldSack;
    private float InhaltSack;
   
    public Geld() {
        super();
    }
    public Geld(float Geldsack, float Inhaltsack) {
        super();
        this.GeldSack = (float) Geldsack;
        this.InhaltSack = (float) Inhaltsack;
    }
    public float getGeldImSack() {
        return GeldSack;
    }

    public float getInhaltImSack() {
        return InhaltSack;
    }

   
    public boolean istKleiner (Geld g, int index) {
        if (index == 1) {
            return this.GeldSack > g.getGeldImSack();
        } else {
            return this.InhaltSack > g.getInhaltImSack();
        }
    }

    @Override
    public String toString() {
        return "(" + GeldSack + "," + InhaltSack + ")";
    }
   
   
}
 

abfdx

Aktives Mitglied
@mihe7 in gewisser Art und Weise schon. Denn es ist deutlich einfacher, den Algorithmus auf die Quotientenliste anzuwenden (Da sie ja in gewisser Art und Weise sinnvoll vorsortiert ist) als auf eine komplett unsortierte Liste.
Danke :)
 
Zuletzt bearbeitet:

eno_x3

Mitglied
Wie DerWissende dir am Anfang schon gesagt hat, muss du für Backtracking Rekursion benutzen. Mit dem Programm da entfernst du dich komplett von Backtracking. Und mit dem Sortieren nach den Quotienten löst du auch nicht das Rucksack Problem. Das wäre eine recht simple Lösung und da wäre bestimmt vor dir schon jemand drauf gekommen^^
Edit: Außerdem machst du das Programm durch float unnötig schwer. Bleib doch erstmal bei int Werten
 

abfdx

Aktives Mitglied
@eno_x3 wie gehe ich dieses Programm denn rekursiv an? Und ich muss ja auf diese Quotientenliste mein Backtracking-/Bruteforce-Verfahren (was auch immer es jetzt ist) anwenden, aber mache es mir halt ein bisschen leichter. Die floats brauchte ich am Anfang nur für die Quotienten, aber dann hab ich halt noch Kommazahlen reingeschrieben und da wollte ich halt nicht double nehmen, weil ich es sonst später nochmal ändern muss blablabla...
Aber die ändern ja nichts am grundsätzlichen Programm, oder?
 

mihe7

Top Contributor
@abfdx Es wird immer schlimmer, weil Du mit völlig ungeeigneten Mitteln an das Problem herangehst und damit Dein Programm "verschlimmbesserst".

Zum Thema wie ich es besser machen würde, habe ich mehrfach versucht, Dich in die richtige Richtung zu lenken. Du wolltest diese Richtung nicht einschlagen. Backtracking ist nun einmal eine Form der Tiefensuche. Das musst Du nicht akzeptieren, aber erwarte nicht, dass Deine "Lösungen" dadurch besser werden.

Knapsack ist NP-vollständig. Wenn Du das mit ein bisschen umsortieren und zwei for-Schleifen deterministisch in Polynomzeit löst, dann lass Dir 1 Mio. USD vom Millenium Prize überweisen und den Turing Award bekommst Du bestimmt noch obendrauf.
 

abfdx

Aktives Mitglied
Ist doch auch ein Lebensziel. Aber ich schätze, ich bin nicht der erste, der das versucht, ebenso wie ich nicht der erste bin, der es nicht schaffen wird. Genau das ist ja der Grund, weswegen ich in einem Forum um Rat bitte ^^

EDIT: Hab die @mihe7 Erwähnung vergessen ^^
 
Zuletzt bearbeitet:

eno_x3

Mitglied
Nur solltest du dann auch auf den Rat eingehen^^ Nein die floats ändern nix am Programm, machen es aber unnötig schwer, zumal Fließkommazahlen ungenau sind.
 

abfdx

Aktives Mitglied
Wie ich schonmal gesagt habe, ich versuche auf jeden Rat einzugehen und freue mich über jede Hilfestellung. Hab aber auch gesagt, dass ich noch ein Anfänger im Bereich Java bin ;D. Wenn du dir jetzt irgendein DAW (Digital Audio Workstation) gekauft hast und ich dir sage, dass der Cutoff nicht wirklich mit der Attack-Time zusammenpasst und der Reverb die Wirkung irgendwie zerstört (was jetzt auch nur ein Beispiel ist), könntest du vermutlich wenig damit anfangen (außer natürlich, du interessierst dich für so etwas und hast dich da schon durchgearbeitet)
 

abfdx

Aktives Mitglied
Deswegen wär es super lieb von euch, wenn ihr eure Hilfestellungen kurz erklärt und mir sagt, wo ich an meinem Programm etwas verändern muss. Natürlich will ich NICHT die Lösung auf dem Silbertablett serviert bekommen, das wäre ja langweilig.
 

mihe7

Top Contributor
Hab aber auch gesagt, dass ich noch ein Anfänger im Bereich Java bin
Das hat mit Java nichts zu tun, so lange Du noch nicht einmal das Problem verstanden hast. Eben damit Du das Problem verstehst, erfolgte der Hinweis auf den Baum. Wenn Du schreibst, dass Du keine Ahnung von Bäumen hast und keinen blassen Schimmer, wie das geht, dann kann man Dir helfen, wenn Du aber schreibst, dass Du es aber so und so machen willst, dann nicht.

wo ich an meinem Programm etwas verändern muss
Du musst erst einmal eine Lösungsstrategie entwickeln, bevor Du irgendwas in Code umsetzt. Nochmal: mit Java hat das alles gar nichts zu tun.
 

abfdx

Aktives Mitglied
Ich hatte mir das am Anfang zum Beispiel so vorgestellt, dass er sich halt die erste Münze nimmt, guckt ob das passt, die nächste Münze(je nachdem, entweder dazunimmt oder statt der ersten nimmt), guckt ob das passt, wenn ja, die nächste dazu, ansonsten probiert er die 3., lässt aber die zweite raus usw. Ein typisches Backtracking verfahren halt. Es fängt aber schon damit an, dass man dazu ja ausrechnen/auslesen muss, wieviele Mögliche Lösungswege an einem Knotenpunkt existieren. Und schon da weiß ich nicht mehr, wie ich das in Java umsetzen kann. Und was bringt mir ein Weltklasse Lösungsweg, wenn ich an der Umsetzung scheitere?
 

mihe7

Top Contributor
Das ist das Problem: wenn das erste passt, ist es immer im Sack. Was aber, wenn das erste zwar passt, aber eine bessere Kombination verhindert? So viel zum "Weltklasse Lösungsweg" ;-)
 

abfdx

Aktives Mitglied
ja wenn er ne lösung gefunden hat, soll er die abspeicher und den schritt rückgängig machen.. warte ich lad gleich mal ne kleine skizze hoch wie ich mir das vorstelle
 

abfdx

Aktives Mitglied
Achso und "Weltklasse Lösungsweg": natürlich, ich bin Mathematiker vom feinsten! Noch nie von der abfdx'schen Lösungsformel gehört?! ;):p
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
Max246Sch 3D Box Filler BAcktracking Java Basics - Anfänger-Themen 1
P Frage zu Rekursion und Backtracking Java Basics - Anfänger-Themen 2
districon Backtracking Java Basics - Anfänger-Themen 2
districon Backtracking Java Basics - Anfänger-Themen 14
districon Dynamisch Programmierung/Backtracking/Memoization Java Basics - Anfänger-Themen 3
districon Backtracking funktioniert nicht ganz Java Basics - Anfänger-Themen 3
V Backtracking und Rekursion Java Basics - Anfänger-Themen 15
G Subset sum problem mit Backtracking Java Basics - Anfänger-Themen 18
O Backtracking Java Basics - Anfänger-Themen 5
C Rekursives Backtracking beim Spiel Peg Java Basics - Anfänger-Themen 22
R Backtracking Java Basics - Anfänger-Themen 1
V Feld sortieren mit Backtracking Java Basics - Anfänger-Themen 1
A Sudoku mit Backtracking lösen Java Basics - Anfänger-Themen 3
L Sudoku Backtracking Pseudocode Java Basics - Anfänger-Themen 3
N Backtracking - Labyrinth/Irrgarten Java Basics - Anfänger-Themen 14
I Backtracking Schach Java Basics - Anfänger-Themen 5
L Magisches Quadrat und Backtracking Java Basics - Anfänger-Themen 19
M Backtracking/Solve Methode Java Basics - Anfänger-Themen 7
P Labyrinth, Backtracking, verzögerte Anzeige Java Basics - Anfänger-Themen 15
D Sudoku lösen mit Backtracking Java Basics - Anfänger-Themen 20
E backtracking und Induktionsprinzip Java Basics - Anfänger-Themen 2
D Backtracking Waage Problem Java Basics - Anfänger-Themen 23
N Backtracking Solohalma Java Basics - Anfänger-Themen 2
W Backtracking und Frustration Java Basics - Anfänger-Themen 6
X Sudoku Backtracking Java Basics - Anfänger-Themen 6
J Solitaire via Backtracking Java Basics - Anfänger-Themen 7
A Backtracking - kennt Java keine Rücksprungmarken? Java Basics - Anfänger-Themen 15
G Backtracking mit globaler Variable Java Basics - Anfänger-Themen 5
M BackTracking Java Basics - Anfänger-Themen 22
J Backtracking Algorithmus Java Basics - Anfänger-Themen 16

Ähnliche Java Themen

Neue Themen


Oben