Ciao a tutti,
sto cercando di risolvere il problema delle otto regine abbinando alla scacchiera classica un'altra scacchiera che riporta l'accessibilità delle caselle. Il problema non è ancora completo. Sono giunto a piazzare una regina in una delle caselle meno accessibili ed ora devo adeguare i valori di accessibilità della scacchiera sottraendovi le caselle già eliminate dalla prima regina (spero di essere stato chiaro). Per ora l'ho risolto in questo modo:
codice:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FALSE 0
#define TRUE 1
#define QUEEN 2

void clearBoard (int[][8]);
void printBoard( int [][8]);
int minAccessBoard (int[][8]);
void takenBoard (int[][8], int, int);
int invalid (int[][8], int , int);

int main(){
    int board[8][8],
    access[8][8] = {22, 22, 22, 22, 22, 22, 22, 22,
                    22, 24, 24, 24, 24, 24, 24, 22,
                    22, 24, 26, 26, 26, 26, 24, 22,
                    22, 24, 26, 28, 28, 26, 24, 22,
                    22, 24, 26, 28, 28, 26, 24, 22,
                    22, 24, 26, 26, 26, 26, 24, 22,
                    22, 24, 24, 24, 24, 24, 24, 22,
                    22, 22, 22, 22, 22, 22, 22, 22},
    currentRow, currentColumn, accessNumber, invalidSquare,
    z, w;
    
    srand(time (NULL));
    clearBoard (board);    

    accessNumber = minAccessBoard (access);
      
    do{
       currentRow = rand() % 8;
       currentColumn = rand() % 8;                
    }while (access[currentRow][currentColumn] > accessNumber);
    
    takenBoard (board, currentRow, currentColumn);
    board[currentRow][currentColumn] = QUEEN;
    
    for (z = 0; z < 8; z++){
        for (w = 0; w < 8; w++){
            invalidSquare = invalid (board, w, z);
            if (board[z][w] == 0){
               access[z][w] -= invalidSquare;
            }
        }
    }
    
    
    printBoard (board);
    
    printBoard (access);
    
    system ("pause");
    
    return 0;
}
void clearBoard (int b[][8])
{
     int k, j;
     
     for (k = 0; k < 8; k++){         
         for (j = 0; j < 8; j++){             
             b[k][j] = FALSE;
         }
     }
}
void printBoard( int workBoard[][ 8 ] )
{ 
   int row, col;

   printf( "   0  1  2  3  4  5  6  7\n" );

   for ( row = 0; row < 8; row++ )
   { 
      printf( "%d", row );

      for ( col = 0; col < 8; col++ )
         printf( "%3d", workBoard[ row ][ col ] );

      printf( "\n" );
    }

   printf( "\n" );
}
int minAccessBoard (int aB[][8])
{
    int k, j, min = 29;
    
    for (k = 0; k < 8; k++){        
        for (j = 0; j < 8; j++){
            if (aB[k][j] < min)
               min = aB[k][j];
        }
    }
    return min;
}
void takenBoard (int tB[][8], int row, int col)
{    
    int i, x, y;
    
    for (i = 0; i < 8; i++){
        x = row;
        y = col;
        
        while (x >= 0 && x < 8 && y >= 0 && y < 8){
              switch (i){
                     case 0:                          
                          tB[x][y++] = TRUE;
                          break;
                     case 1:
                          tB[x++][y++] = TRUE;
                          break;
                     case 2:
                          tB[x++][y] = TRUE;
                          break;
                     case 3:
                          tB[x++][y--] = TRUE;
                          break;
                     case 4:
                          tB[x][y--] = TRUE;
                          break;
                     case 5:
                          tB[x--][y--] = TRUE;
                          break;
                     case 6:
                          tB[x--][y] = TRUE;
                          break;
                     case 7:
                          tB[x--][y++] = TRUE;
                          break;
              }
        }
    }
}
int invalid (int board[][8], int a, int b)
{
     int i, x, y, sum = 0;
     
     for (i = 0; i < 8; i++){
         x = a;
         y = b;
         while (x >= 0 && x < 8 && y >= 0 && y < 8){
               switch (i){
                      case 0:                          
                           sum += board[x][y++];
                           break;
                      case 1:
                           sum += board[x++][y++];
                           break;
                      case 2:
                           sum += board[x++][y];
                           break;
                      case 3:
                           sum += board[x++][y--];
                           break;
                      case 4:
                           sum += board[x][y--];
                           break;
                      case 5:
                           sum += board[x--][y--];
                           break;
                      case 6:
                           sum += board[x--][y];
                           break;
                      case 7:
                           sum += board[x--][y++];
                           break;
               }
         }
     }
     return sum;
}
per quanto riguarda il piazzamento della regina tutto bene. Però non riesco a capire perchè alcuni valori di accessibilità siano sballati.
Sono tre giorni che ci perdo la testa.
Mi sapete consigliare??
p.s. Non sono ho ancora studiato i puntatori