Ασκηση προγραμματισμου

GRAPS · 6 Μαΐου 2010

κξασηδκασηφαφησκνψφασκξψφα

Luffy-san · 6 Μαΐου 2010

:-D:-D:-D:-D:-D:-D

C6WGMN · 6 Μαΐου 2010

αν μπορει καποιος ας με βοηθησει λιγο...

σασ ευχαρηστω πολυ..

Έως ποιό βαθμό δέχεσε τον εξεφτελισμό έναντι της λύσης?

tespa_2002 · 6 Μαΐου 2010

Αν ξέρεις από αναδρομή, η καλύτερη λύση είναι η αναδρομική.

Ξεκινάς από μια γωνία. Σε κάθε βήμα δοκιμάζεις καθεμιά από τις εναλλακτικές θέσεις στις οποίες μπορεί να φτάσει ο ιππότης από τη θέση που βρίσκεσαι. Για καθεμιά από τις νέες θέσεις ξεκινάς μια νέα αναδρομή για να βρεις όλες τις πιθανές διαδρομές από εκεί και πέρα. Κάθε τετράγωνο στο οποίο έχεις ήδη πατήσει το μαρκάρεις.

Η αναδρομή σου σταματάει να προχωράει σε βάθος είτε:

α) Όταν δεν έχεις κάπου να πας από κάποια θέση (αποτυχία)

β) Όταν έχεις περάσει από όλα τα τετράγωνα (και άρα έχεις βρει μια σωστή διαδρομή).

Επειδή υπάρχει ένα hint για σωρό στην άσκηση, μπορείς να φτιάξεις τη λύση όχι αναδρομικά, αλλά ισοδύναμα επαναληπτικά. Στο σωρό (ή κατ' ακρίβεια στη στοίβα) θα πρέπει να κρατάς τις κινήσεις που έχεις κάνει έως τώρα.

Για να πάρεις παραπάνω βοήθεια από οποιονδήποτε εδώ μέσα θα πρέπει να παρουσιάσεις την έως τώρα προσπάθειά σου σε κώδικα

C6WGMN · 6 Μαΐου 2010

Μια ιδέα: κάθε τετράγωνο μπορείς να το αναπαραστήσεις με ένα αριθμό από 1 έως 64. Σταματάς όταν το άθροισμα των "μαυρισμένων" τετραγώνων είναι 64*65/2. Η συνάρτηση των πιθανών κινήσεων θα δίνει μία λίστα από triplets, όπου κάθε στοιχείο είναι ένας αριθμός που μαύρισες.

V.I.Smirnov · 6 Μαΐου 2010

Η καλύτερη λύση είναι με αναδρομή.

Όπως και στο πιο κλασσικό πρόβλημα με τις εννιά βασίλισσες.

Και για δες σύμπτωση, την είχα αναφέρει σε προηγούμενο thread...

Μπορεί να λυθεί και επαναληπτικά με χρήση stack όπως υπαινίσσεται η άσκηση αλλά εγώ δεν θα το δοκίμαζα έτσι.

Ξεκίνα να διαβάζεις την θεωρία/παραδείγματα για τα stacks φίλε και μην ζητάς έτοιμο κώδικα.

javavall · 6 Μαΐου 2010

Έλεος!!! EPIC FAIL! Φτάνουνε ως εδώ οι ceidades. Ρε συ GRASP το forum της σχολής γιατί το έχουμε? Δίνεις και αυτούσια την εκφώνηση. Αναρωτιέμαι πως θα λύσεις το δέντρο μετά. Χρησιμοποίησε και το google που κ που δεν κάνει κακό.

Η αναδρομή είναι η χειρότερη λύση από πλευράς απόδοσης. Warnsdorff's algorithm ftw

V.I.Smirnov έχεις ιδιαίτερη αγάπη στην αναδρομή ή μου φαίνεται?

V.I.Smirnov · 7 Μαΐου 2010

Έλεος!!! EPIC FAIL! Φτάνουνε ως εδώ οι ceidades. Ρε συ GRASP το forum της σχολής γιατί το έχουμε? Δίνεις και αυτούσια την εκφώνηση. Αναρωτιέμαι πως θα λύσεις το δέντρο μετά. Χρησιμοποίησε και το google που κ που δεν κάνει κακό.

Η αναδρομή είναι η χειρότερη λύση από πλευράς απόδοσης. Warnsdorff's algorithm ftw

V.I.Smirnov έχεις ιδιαίτερη αγάπη στην αναδρομή ή μου φαίνεται?

Για το δεύτερο, το είπα και αλλού : δεν έχω καμιά εμμονή με την αναδρομή.

Απλώς είναι ένα θέμα παραγνωρισμένο από τους ερασιτέχνες.

Εξάλλου εδώ δεν το ανέφερα εγώ.

Για το πρώτο που γράφεις δεν διαφωνώ τελείως.

Πχ. είναι σίγουρα χειρότερη από την επαναληπτική λύση όταν σε κάθε βήμα υπολογίζονται τιμές που ήδη έχουν βρεθεί σε προηγούμενα βήματα.

Αλλά σε αρκετές περιπτώσεις είναι ευκολότερο να βρεθεί μια αναδρομική λύση από μια επαναληπτική.

Σε ότι αφορά το συγκεκριμένο πρόβλημα, όπως και αυτό με τις n βασίλισσες, είναι κλασσικό και υπάγεται σ' αυτή την κατηγορία - πουθενά δεν θυμάμαι να το λύνουν επαναληπτικά.

poscaman · 7 Μαΐου 2010

To ταξίδι του Ιππότη
Στο σκάκι ο ιππότης μπορεί να κινηθεί κατά εμπρός, πίσω, δεξιά και αριστερά από τη θέση που βρίσκεται κατά

δύο θέσεις προς τον ένα άξονα και στην συνέχεια κατά μία (από τη μία μεριά ή από την άλλη) ως προς τον άλλον

βλέπε σχήμα (κόκκινη είναι η αρχική θέση και μαύρες μία από τις πιθανές θέσεις όπου μπορεί να καταλήξει). Το

ταξίδι του ιππότη στη σκακιέρα (8x8 θέσεις) είναι η συνεχόμενη μετακίνηση αυτού από θέση σε θέση έτσι ώστε

να περάσει από όλες τις θέσεις μία φορά. Γράψτε ένα πρόγραμμα όπου θα υπολογίζει ένα τέτοιο ταξίδι του

ιππότη ξεκινώντας από μία από τις 4 γωνίες. α) Περιγράψτε εποπτικά των αλγόριθμο β) δώστε κώδικα γ) βρείτε

την πολυπλοκότητα του αλγορίθμου σας και δείτε και στην πράξη αν χρόνος εκτέλεσης ακολουθεί την

πολυπλοκότητα αυτή. (Σημείωση: μπορείτε να χρησιμοποιήσετε σωρό).

αν μπορει καποιος ας με βοηθησει λιγο...

σασ ευχαρηστω πολυ..

ρε καρακατεστραμένε CEIDά, μη βγάζεις στην απόξω τα σουπεργαμάτα θεματάκια της προεδράρας μας...

paylidis · 7 Μαΐου 2010

χαιρετώ του αυριανούς επιστήμονες που κάνουν λάθη μεχρι και στο "ευχαριστώ"...

Μετά λέμε γιατι είναι μπου_δελο το συστημα εισαγωγής στην τριτοβάθμια...

V.I.Smirnov · 7 Μαΐου 2010

χαιρετώ του αυριανούς επιστήμονες που κάνουν λάθη μεχρι και στο "ευχαριστώ"...

Μετά λέμε γιατι είναι μπου_δελο το συστημα εισαγωγής στην τριτοβάθμια...

Η ορθογραφία δεν είναι από τα δυνατά σημεία πολλών εδώ πέρα.

Και αν τους κάνεις παρατήρηση θα ακούσεις τον εξάψαλμο όπως μου συνέβη.

Το κακό δεν είναι τα εκ παραδρομής λάθη αλλά ότι πολλοί θεωρούν φυσιολογικό να είναι τόσο ανορθόγραφοι επειδή βρίσκονται σε προγραμματιστικό forum...

Ιδού μια πλήρη λύση με αναδρομή στο πρόβλημα του ιππότη.

Το παρακάτω πρόγραμμα βρίσκει όλες τις δυνατές διαδρομές για αυθαίρετο μέγεθος "σκακιέρας" δηλ. n x m.

Kάθε φορά που βρίσκεται μια λύση τυπώνει έναν n x m πίνακα.

H ζητούμενη διαδρομή είναι η ακολουθία των τετραγώνων με διαδοχικούς αριθμούς : 1 -> 2 -> 3 -> ... -> 64.

Αν δεν κάνω λάθος, το πρόβλημα αυτό είναι η εύρεση μιας διαδρομής Hamilton - οι ειδικοί ας με διορθώσουν...

>
//Knight_tour_problem

#include <stdlib.h>
#include <stdio.h>

int   **allocMat2DInt(unsigned numRows,unsigned numColumns,int initValue);
void   deAllocMat2DInt(int **array, unsigned numRows);
void   printMat2DInt(int **array, unsigned numRows, unsigned numColumns);
bool   isLegalMove(unsigned i,unsigned j,unsigned i_new,unsigned j_new,unsigned numRows,unsigned numColumns);
void   moveKnight(int **board,unsigned i,unsigned j,unsigned numRows,unsigned numColumns,unsigned step,int *recursionCounter);
unsigned numOfSolutions=0;

void main()
{
  unsigned numRows,numColumns;
  int      recursionCounter;
  int      **board;
  
  printf("Enter the number of rows and columns of board: ");
  scanf("%u %u",&numRows,&numColumns);
  board = allocMat2DInt(numRows,numColumns,0);
  if (board==NULL)
  {
     printf("Array allocation failed !\n");
     getchar();
     return;
  }

  recursionCounter = 0;
  moveKnight(board,0,0,numRows,numColumns,1,&recursionCounter);
  
  printf("\nThe total of all possible solutions found are %d \n",numOfSolutions);
  printf("\nThe total number of recursive calls was %d \n",recursionCounter);

  _flushall(); getchar();

  deAllocMat2DInt(board,numRows);
  return;
}

int **allocMat2DInt(unsigned numRows,unsigned numColumns,int initValue)
{
  unsigned i, j;
  int **array = (int**) malloc(numRows*sizeof(int *));

  if (array == NULL) 
     return NULL;

  for(i = 0; i < numRows; ++i) 
  {
     array[i] = (int*) malloc(numColumns*sizeof(int));
     if (array[i] == NULL) 
     {
        for (j = i-1; j>= 0; --j) 
        {
           free(array[j]);
        }
        free(array);
        return NULL;
     }
  }
  
  for (i = 0;i < numRows; ++i)
     for (j = 0; j < numColumns; ++j)
        array[i][j] = initValue;

  return array;
}

void deAllocMat2DInt(int **array, unsigned numRows)
{
  unsigned i;

  for (i = 0; i < numRows; ++i) 
     free(array[i]);

  free(array);
}

void printMat2DInt(int **array, unsigned numRows, unsigned numColumns)
{
  unsigned i, j;
  for (i = 0; i < numRows; ++i) 
  {
     printf("\n");
     for (j = 0; j < numColumns; ++j) 
     {
        printf("%5d", array[i][j]);
     }
     printf("\n");
  }
}

bool  isLegalMove(unsigned i,unsigned j,unsigned i_new,unsigned j_new,unsigned numRows,unsigned numColumns)
{
  bool answer = false;
  if (
        ((i_new <= numRows - 1) && (i_new >= 0) && (j_new <= numColumns - 1) && (j_new >= 0)) 
        &&   (      (i_new == i-1 && j_new == j+2)
                ||  (i_new == i+1 && j_new == j+2)
                ||  (i_new == i-2 && j_new == j+1)
                ||  (i_new == i+2 && j_new == j+1)
                ||  (i_new == i-2 && j_new == j-1)
                ||  (i_new == i+2 && j_new == j-1)
                ||  (i_new == i-1 && j_new == j-2)
                ||  (i_new == i+1 && j_new == j-2)
              )
     )
     answer = true;

  return answer;
}

void moveKnight(int **board,unsigned i,unsigned j,unsigned numRows,unsigned numColumns,unsigned step,int *recursionCounter)
{
  ++(*recursionCounter);
  board[i][j]=step;     // αύξων αριθμός βήματος

  if (step==numRows*numColumns)
  {
     // a solution was found - print it
     ++numOfSolutions;
     printf("\nAt recursion number %d a solution was found :\n",*recursionCounter);
     printMat2DInt(board,numRows,numColumns);
     printf("\nPress <Enter> to continue searching...");
     //getchar();
     return;
  }
  else
  {
        // check and find the possible moves
        if (isLegalMove(i,j,i-1,j+2,numRows,numColumns) && board[i-1][j+2]==0)
        {
           moveKnight(board,i-1,j+2,numRows,numColumns,step + 1,recursionCounter);
           board[i-1][j+2]=0;
        }

        if (isLegalMove(i,j,i+1,j+2,numRows,numColumns) && board[i+1][j+2]==0)
        {
           moveKnight(board,i+1,j+2,numRows,numColumns,step + 1,recursionCounter);
           board[i+1][j+2]=0;
        }

        if (isLegalMove(i,j,i-2,j+1,numRows,numColumns) && board[i-2][j+1]==0)
        {
           moveKnight(board,i-2,j+1,numRows,numColumns,step + 1,recursionCounter);
           board[i-2][j+1]=0;
        }

        if (isLegalMove(i,j,i+2,j+1,numRows,numColumns) && board[i+2][j+1]==0)
        {
           moveKnight(board,i+2,j+1,numRows,numColumns,step + 1,recursionCounter);
           board[i+2][j+1]=0;
        }

        if (isLegalMove(i,j,i-2,j-1,numRows,numColumns) && board[i-2][j-1]==0)
        {
           moveKnight(board,i-2,j-1,numRows,numColumns,step + 1,recursionCounter);
           board[i-2][j-1]=0;
        }

        if (isLegalMove(i,j,i+2,j-1,numRows,numColumns) && board[i+2][j-1]==0)
        {
           moveKnight(board,i+2,j-1,numRows,numColumns,step + 1,recursionCounter);
           board[i+2][j-1]=0;
        }

        if (isLegalMove(i,j,i-1,j-2,numRows,numColumns) && board[i-1][j-2]==0)
        {
           moveKnight(board,i-1,j-2,numRows,numColumns,step + 1,recursionCounter);
           board[i-1][j-2]=0;
        }

        if (isLegalMove(i,j,i+1,j-2,numRows,numColumns) && board[i+1][j-2]==0)
        {
           moveKnight(board,i+1,j-2,numRows,numColumns,step + 1,recursionCounter);
           board[i+1][j-2]=0;
        }
  }

  return;
}

Η ιδέα είναι πολύ απλή : ελέγxεται από τις 8 δυνατές κινήσεις ποιές μπορούν να γίνουν σε τετράγωνο που βρίσκεται εντός της σκακιέρας και δεν έχει ήδη σαρωθεί.

Αν κάποιο βήμα είναι αποδεκτό σύμφωνα με το παραπάνω κριτήριο, η συνάρτηση ξανακαλεί τον εαυτό της μετρώντας ένα βήμα περισσότερο.

Η υπόθεση τερματισμού είναι να συμπληρωθεί το μέγιστο πλήθος αποδεκτών βημάτων οπότε θα έχει βρεθεί μια διαδρομή.

Το μέγιστο αυτό πλήθος είναι n x m βήματα (δηλ. 64 για 8x8) αφού όλα τα τετράγωνα πρέπει να σαρωθούν.

Ο αλγόριθμος τείνει στη λύση διότι, για κάθε βήμα που γίνεται δεκτό, το συνολικό πλήθος βημάτων αυξάνεται κατά 1 πλησιάζοντας στο τελικό nxm.

Αν μια σειρά βημάτων οδηγήσει σε λύση, το τετράγωνο αφετηρίας σημαδεύεται με μηδέν ως ένδειξη ότι σαρώθηκε και δεν πρέπει να χρησιμοποιηθεί πάλι.

Αυτά αφορούν μία διαδρομή.

Επειδή η επεξεργασία των αναδρομικών κλήσεων συνεχίζεται και μετά από την εύρεση κάποιας διαδρομής, το αποτέλεσμα είναι να αναζητούνται όλες οι δυνατές λύσεις.

Ενδεικτικά, από τις δοκιμές που έκανα βρήκα ότι για "σκακιέρες"

- 4x4 γίνονται 2223 κλήσεις και υπάρχουν 0 διαδρομές

- 5x5 γίνονται 1735079 κλήσεις και υπάρχουν 304 διαδρομές

- 6x6 γίνονται 2251955775 κλήσεις και υπάρχουν 524486 διαδρομές

Για σκακιέρα 8x8, πιθανόν απαιτείται μεγαλύτερο εύρος ακεραίων από αυτό που χρησιμοποιώ - πάντως βρίσκει τις πρώτες.

Μια επαναληπτική λύση του προβλήματος θα είναι αρκετά πιο πολύπλοκη διότι η χρήση του stack

πρέπει να γίνει άμεσα στον αλγόριθμο από τον προγραμματιστή ενώ εδώ γίνεται έμεσα λόγω των κλήσεων.

Εξάλλου, η παραπάνω αναδρομική λύση δεν είναι tail-recursion και συνεπώς μετατροπή της σε επαναληπτική είναι δύσκολη.

tespa_2002 · 7 Μαΐου 2010

Ωραία, να συμφωνήσουμε όμως να μη δίνουμε φόρα παρτίδα κώδικα σε όποιον το ζητάει χωρίς να δείξει το ελάχιστο προσπάθειας;

Δηλαδή πέραν του ότι να δώσει ο GRAPS μια έτοιμη άσκηση για την οποία δε θα έχει ιδέα και συνεπώς να μη μάθει τίποτα, και πέραν του να δείξει ο καθένας από εμάς ότι μπορεί να λύσει την άσκηση, τι ακριβώς καταφέραμε;

Τώρα που το ξανασκέφτομαι, ούτε καν την έτοιμη άσκηση δε μπορεί να δώσει, εκτός αν ο καθηγητής του κοιμάται όρθιος...

javavall · 7 Μαΐου 2010

γ) βρείτε
την πολυπλοκότητα του αλγορίθμου σας και δείτε και στην πράξη αν χρόνος εκτέλεσης ακολουθεί την

πολυπλοκότητα αυτή.

Ξέχασες να γράψεις και αυτό.

V.I.Smirnov · 7 Μαΐου 2010

Ωραία, να συμφωνήσουμε όμως να μη δίνουμε φόρα παρτίδα κώδικα σε όποιον το ζητάει χωρίς να δείξει το ελάχιστο προσπάθειας;

Δηλαδή πέραν του ότι να δώσει ο GRAPS μια έτοιμη άσκηση για την οποία δε θα έχει ιδέα και συνεπώς να μη μάθει τίποτα, και πέραν του να δείξει ο καθένας από εμάς ότι μπορεί να λύσει την άσκηση, τι ακριβώς καταφέραμε;

Τώρα που το ξανασκέφτομαι, ούτε καν την έτοιμη άσκηση δε μπορεί να δώσει, εκτός αν ο καθηγητής του κοιμάται όρθιος...

Φίλε μου, ξενύχτησα για να γράψω την λύση όχι γι' αυτόν αλλά κυρίως για μένα και σένα και για όλους τους άλλους που θα ενδιαφερθούν να τη διαβάσουν.

Εγώ, αν είχα πρόβλημα κατανόησης κάποιου θέματος, θα ήθελα να δω έτοιμη μια σχεδόν πλήρη λύση για να επωφεληθώ από την

εμπειρία του άλλου που ξέρει περισσότερα - και το έχω κάνει κατά καιρούς. Και για φοιτητικές εργασίες.

Αλλά το έκανα και ενίοτε το κάνω στα πλαίσια πάντα του να έχω καλή βάση για να μελετήσω κι όχι για να αντιγράψω παθητικά και να κοροϊδέψω.

Προφανώς ο τύπος που ζήτησε βοήθεια θα πρέπει να μελετήσει τον κώδικα και αυτό δεν θα είναι εύκολο αν είναι άσχετος και αδιάφορος.

Επιπλέον, πιθανότητα η άσκηση πρέπει να λυθεί επαναληπτικά αφού δίνει έναν υπαινιγμό για χρήση stack, συνεπώς η λύση μου είναι μεν

ολόσωστη αλλά δεν ανταποκρίνεται αναγκαστικά στο διδακτικό ζητούμενο της εκφώνησης.

Πρωταρχικά την έγραψα για να γίνει συζήτηση μεταξύ μας κι' όχι γι' αυτόν που τη ζήτησε.

Η λύση του προβλήματος με τον παραπάνω τρόπο απαιτεί οξυδέρκεια που συνήθως δεν έχει κάποιος σε ένα εισαγωγικό μάθημα.

Εγώ είχα μελετήσει κάποτε την τεχνική μόνος μου αλλιώς δεν θα μπορούσα να τη λύσω.

Πώς είναι δυνατόν να δεχτεί ο εξεταστής μια μη τετριμένη απάντηση χωρίς να του κινηθεί το ενδιαφέρον για την προέλευσή της ;

Μάτι βγάζει ότι δεν μπορεί να είναι δική του. Εγώ θα τον ξετίναζα :

Ποιά είναι η σχέση της αναδρομής με την επαγωγή, ποιά είναι η βασική υπόθεση, ποιό είναι το βήμα της επεξεργασίας,

γενικά πότε υπάρχει σύγκλιση και γιατί συγκλίνει ο συγκεκριμένος αλγόριθμος, αν μπορεί/συμφέρει να μετατραπεί σε επαναληπτική και αν ναι πώς...

Δίνεις έτοιμη λύση κύριε ; δεκτή, αλλά να την κατέχεις. Παθητική αντιγραφή να συνεπάγεται μηδενισμό.

Aν ο εξεταστής είναι τόσο αδιάφορος ώστε να δεχθεί 200 γραμμές κώδικα χωρίς να ελένγξει την γνωστική επάρκεια του

φοιτητή ή/και χωρίς να ανταποκρίνεται η λύση αυτή στο διδακτικό περιεχόμενο της εκφώνησης,

η ευθύνη του φοιτητή που θέλει να κοροϊδέψει είναι μισή. Η άλλη μισή είναι του εξεταστή.

Η νοοτροπία όμως αυτή, να ζητάνε πολλοί έτοιμο φαϊ στο πιάτο χωρίς να ενδιαφέρονται και πραγματικά να ασχολούνται έχει διογκωθεί

τελευταία και το έχω κριτικάρει κι εγώ. Ακόμη περισσότερο μάλιστα από ανθρώπους που νομίζουν ότι αρκεί να φοιτήσουν σε μια σχολή

για να παριστάνουν τους επιστήμονες και ότι έχουν υψηλο IQ ενώ καν δεν ξέρουν την στοιχειώδη ορθογραφία.

Υπόσχομαι λοιπόν να μην παράσχω τα όποια φωτα μου (εξάλλου δεν έχω σπουδές πληροφορικής) σε περιπτώσεις όπου ζητούν

όχι βοήθεια και έναυσμα για μελέτη αλλά μόνον έτοιμη δουλειά που δεν θέλουν να κάνουν οι ίδιοι επειδή είναι αδιάφοροι/ανίκανοι/τεμπέληδες.

Και αν εγώ χρειαστώ βοήθεια σε κάτι να μου την δώσετε έστω με προσωπικό μύνημα αν δεν θέλετε να κοινοποιηθεί.

Ζητώ την κατανόησή σας...

Directx · 7 Μαΐου 2010

To ταξίδι του Ιππότη
Στο σκάκι ο ιππότης μπορεί να κινηθεί κατά εμπρός, πίσω, δεξιά και αριστερά από τη θέση που βρίσκεται κατά

δύο θέσεις προς τον ένα άξονα και στην συνέχεια κατά μία (από τη μία μεριά ή από την άλλη) ως προς τον άλλον

βλέπε σχήμα (κόκκινη είναι η αρχική θέση και μαύρες μία από τις πιθανές θέσεις όπου μπορεί να καταλήξει). Το

ταξίδι του ιππότη στη σκακιέρα (8x8 θέσεις) είναι η συνεχόμενη μετακίνηση αυτού από θέση σε θέση έτσι ώστε

να περάσει από όλες τις θέσεις μία φορά. Γράψτε ένα πρόγραμμα όπου θα υπολογίζει ένα τέτοιο ταξίδι του

ιππότη ξεκινώντας από μία από τις 4 γωνίες. α) Περιγράψτε εποπτικά των αλγόριθμο β) δώστε κώδικα γ) βρείτε

την πολυπλοκότητα του αλγορίθμου σας και δείτε και στην πράξη αν χρόνος εκτέλεσης ακολουθεί την

πολυπλοκότητα αυτή. (Σημείωση: μπορείτε να χρησιμοποιήσετε σωρό).

αν μπορει καποιος ας με βοηθησει λιγο...

σασ ευχαρηστω πολυ..

Δες στο http://en.wikipedia.org/wiki/Knight's_tour. Προσωπικά (και σε C++/STL) μου φάνηκε ευκολότερη η υλοποίηση του "Warnsdorff’s algorithm".

Σύνδεση

Ασκηση προγραμματισμου

Προτεινόμενες αναρτήσεις

GRAPS

Luffy-san

C6WGMN

tespa_2002

C6WGMN

V.I.Smirnov

javavall

V.I.Smirnov

poscaman

paylidis

V.I.Smirnov

tespa_2002

javavall

V.I.Smirnov

Directx

Αρχειοθετημένο

Σύνδεση