Ti cairico tutto
classe Tabella.h
codice:
#include "Casella.h"
#include <vector>
#include <iostream>
#include <string>
#include <ctime>
#include <cstdlib>
class Tabella
{
private:
int sizeTabella;
int sizeRegione;
int livelloDifficolta;
std::vector<std::vector<Casella*>*> *tabella = new std::vector<std::vector<Casella*>*>();
public:
Tabella(int sizeRegione, int livello); /*Crea Tabella di Default a 0*/
~Tabella();
void mostraSudoku();
bool controllaVincoli(Casella* casellaDaControllare); //OVERLOADING DI METODI
bool controllaVincoli(int, int, int );
long int BackTracking();
};
/*Crea Tabella di Default a 0*/
Tabella::Tabella(int sizeRegione, int livelloDifficolta)
{
this->livelloDifficolta = livelloDifficolta;
this->sizeRegione = sizeRegione;
this->sizeTabella = sizeRegione*sizeRegione;
int quantitaNumeriFissi = this->sizeTabella*this->sizeTabella; //inizializiamo la quantità di fissi alla quantità di numeri in totale in tabella
//per calcolare su di essa in seguito la percentuale di numeri fissi tramite lo
//costrutto Switch - Case
switch (this->livelloDifficolta)
{
case 3:
quantitaNumeriFissi = (int)floor((quantitaNumeriFissi * 5) / 100);
break;
case 2:
quantitaNumeriFissi = (int)floor((quantitaNumeriFissi * 25) / 100);
break;
case 1:
quantitaNumeriFissi = (int)floor((quantitaNumeriFissi * 50) / 100);
break;
}
/**** INIZIO CREAZIONE STRUTTURA MATRICIALE ****/
//Creo un vector di puntatori vector di puntatori Caselle di Default (valore=0).
//Simulo così una matrice di 0
for (int i = 0; i < this->sizeTabella; i++)
{
std::vector<Casella*> *vec = new std::vector<Casella*>;
this->tabella->push_back(vec);
for (int j = 0; j < this->sizeTabella; j++)
{
Casella *casella = new Casella(i, j); //Il Costruttore di Default di Casella, genera numero=0 e fisso=false
tabella->at(i)->push_back(casella); //sull'i-esimo vettore di vettore inseriamo in coda una Casella di valore 0
//std::cout << "inserita casella " << casella->getRiga() <<" "<<casella->getColonna()<< std::endl;
}
}
/**** INIZIO INSERIMENTO NUMERI FISSI IN TABELLA ****/
int riga = 0; int colonna = 0; int valore = 0;
srand((unsigned)time(NULL));
for (int i = 0; i < quantitaNumeriFissi; i++)
{
riga = (rand() % (this->sizeTabella));
colonna = (rand() % (this->sizeTabella));
valore = (rand() % (this->sizeTabella)) + 1;
std::cout << "rand 1 =" << valore << std::endl;
Casella *casella = new Casella(valore, riga, colonna);
if (this->tabella->at(riga)->at(colonna)->getNumero() == 0 && this->controllaVincoli(casella) == true) //se quel valore è gia presente in riga, colonna o regione
{
valore = (rand() % (this->sizeTabella)) + 1; //calcola un valore diverso
std::cout << "rand 2 =" << valore << std::endl;
casella->setNumero(valore);
casella->setFisso(true);
}
this->tabella->at(riga)->at(colonna) = casella;
this->mostraSudoku();
//system("PAUSE");
}
/************FINE INSERIMENTO NUMERI FISSI ******************/
};
Tabella::~Tabella()
{
for (int i = 0; i < tabella->size(); i++)
{
for (int j = 0; j < tabella->size(); j++)
{
delete tabella->at(i)->at(j); //sull'i-esimo vettore di vettore inseriamo in coda 0
}
tabella->at(i)->clear(); //libera la memoria di ogni vettore
delete tabella->at(i);
}
tabella->clear();
delete tabella;
}
/*** CONTROLLO DEI VINCOLI DI BACKTRACKING ***/
//Questo metodo, controlla se il numero della casella presa in argomento sia uguale al numero di una presente
//sulla stessa riga, colonna o regione
//l'uguaglianza è verificata attraverso RICERCA SEQUENZIALE ITERATIVA
bool Tabella::controllaVincoli(Casella* casellaDaControllare)
{
bool esistenza = false;
//CONTROLLO PRIMO VINCOLO - ESISTENZA SU STESSA RIGA
int ii = casellaDaControllare->getRiga();
int jj = 0;
while (jj < this->sizeTabella && this->tabella->at(ii)->at(jj)->getNumero() != casellaDaControllare->getNumero())
jj++;
if (jj == this->sizeTabella)
esistenza = false;
else
esistenza = true;
//CONTROLLO SECONDO VINCOLO - ESISTENZA SU STESSA COLONNA
ii = 0;
jj = casellaDaControllare->getColonna();
while (ii < this->sizeTabella && this->tabella->at(ii)->at(jj)->getNumero() != casellaDaControllare->getNumero())
ii++;
if (ii == this->sizeTabella)
esistenza = esistenza && false;
else
esistenza = esistenza && true;
//CONTROLLO TERZO VINCOLO - ESISTENZA IN REGIONE
/*
.
.
.
.
.
.*/
std::cout << "esistenza = " << esistenza << std::endl;
return esistenza;
};
/*** FINE CONTROLLO VINCOLI ***/
void Tabella::mostraSudoku()
{
std::string *barra = new std::string("--------"); //unità semplice di una barra grafica inferiore
for (int k = 0; k < this->sizeRegione - 1; k++) //la barra viene aumentata in relazione alla grandezza e alla quantità di Regioni
{
barra->append(*barra);
}
for (int i = 0; i < tabella->size(); i++)
{
for (int j = 0; j < tabella->size(); j++)
{
if (tabella->at(i)->at(j)->getNumero() >= 10)
{
std::cout << (tabella->at(i)->at(j)->getNumero()) << " ";
}
else if (tabella->at(i)->at(j)->getNumero() <= 9 && tabella->at(i)->at(j)->getNumero() >= 0)
{
std::cout << (tabella->at(i)->at(j)->getNumero()) << " ";
}
if (j % sizeRegione == sizeRegione - 1) std::cout << "| ";
}
if (i % sizeRegione == sizeRegione - 1)
{
std::cout << std::endl << *barra << std::endl;
}
std::cout << std::endl;
}
};
classe Casella.h
codice:
#ifndef _SUDOKU_#define _SUDOKU_
#include <vector>
#include <ctime>
#include <cstdlib>
class Casella {
private:
int numero;
int riga;
int colonna;
bool fisso; //Se è Numero Fisso = TRUE, se Numero Non Fisso = FALSE
public:
Casella(int riga, int colonna);
Casella(int numero, int riga, int colonna);
Casella(int numero, int riga, int colonna, bool fisso);
~Casella();
void setNumero(int numero){ this->numero = numero; };
void setRiga(bool fisso){ this->fisso = fisso; };
void setColonna(int colonna){ this->colonna = colonna; };
void setFisso(bool fisso){ this->fisso = fisso; };
int getNumero(){ return this->numero; };
int getRiga(){ return this->riga; };
int getColonna(){ return this->colonna; };
bool getFisso(){ return this->fisso; };
};
/* OVERLOADING DI COSTRUTTORI */
Casella::Casella(int riga, int colonna){
this->numero = 0;
this->fisso = false;
this->riga = riga;
this->colonna = colonna;
};
Casella::Casella(int numero, int riga, int colonna){
this->numero = numero;
this->fisso = false;
this->riga = riga;
this->colonna = colonna;
};
Casella::Casella(int numero, int riga, int colonna, bool fisso)
{
this->numero = numero;
this->fisso = fisso;
this->riga = riga;
this->colonna = colonna;
}
/* FINE OVERLOADING */
Casella::~Casella(){
delete this;
}
#endif
file cpp Sudoku.cpp
codice:
#include "stdafx.h"
#include "Tabella.h"
#include <iostream>
//#include "Tabella.h"
int _tmain(int argc, _TCHAR* argv[])
{
int size = 0;
int livello = 0;
std::cout << "Inserisci il size di riga e colonna della Cella: " << std::endl;
std::cin >> size;
std::cout << "Inserisci il livello di difficolta' " << std::endl;
std::cout << "[1] : Inesperto" << std::endl << "[2] : Medio" << std::endl << "[3] : Esperto" << std::endl;
std::cin >> livello;
Tabella *tabella = new Tabella(size,livello);
tabella->mostraSudoku();
system("PAUSE");
return 0;
}
cmq ho l'impressione che sia il corpo di quel metodo contollaVincoli(Casella *casellaDaControllare) che non funziona bene dentro. ma non mi spiego perchè dato che implementa una semplice ricerca sequenziale presa da wiki!
spero tu riesca... io sto letteralmente impazzendo.
GRAZIE MILLE!!!
Rispondi quotando
l'ho cambiato in qualcosa di più sintetico.