int searchSolutions(int sudoku[SUDOKU_SIZE][SUDOKU_SIZE], int solutions[SUDOKU_SIZE][SUDOKU_SIZE]) {
int i, j;
int solutionsCount = 0;
for (i = 0; i < SUDOKU_SIZE; i++) {
for (j = 0; j < SUDOKU_SIZE; j++) {
if (sudoku[i][j] > 0)
continue;
int seen[SUDOKU_SIZE];
initArray(seen, SUDOKU_SIZE, 0);
elementsInColumn(seen, sudoku, j);
elementsInLine(seen, sudoku, i);
elementsInRegion(seen, sudoku, i - (i % (SUDOKU_SIZE / 3)), j - (j % (SUDOKU_SIZE / 3)));
int k = 0;
for (k = 0; k < SUDOKU_SIZE; k++) {
if (seen[k] == 0) {
solutions[i][j] += 1 << k + 1;
solutionsCount++;
}
}
}
}
return solutionsCount;
}
void OpenSMOKE_MatrixSparsityPattern::FindDependence()
{
const int max_length_int_vector = static_cast<int> (std::pow(2., 32.) - 1);
if (is_dependence_available_ == true)
return;
is_dependence_available_ = true;
ElementSparsityPattern *elem;
number_elements_ = 0;
max_elements_in_rows_ = 0;
min_elements_in_rows_ = columns_;
max_elements_in_cols_ = 0;
min_elements_in_cols_ = rows_;
number_equations_per_variable_ = new int[columns_ + 1];
memset(number_equations_per_variable_, 0, (columns_ + 1)*sizeof(int));
int maxRow, minRow;
OpenSMOKE::OpenSMOKEVectorInt elementsInColumn(columns_);
number_zeros_on_diagonal_ = 0;
for (int row = 1; row <= rows_; row++)
{
maxRow = 0;
minRow = 0;
elem = element_row_[row];
while (elem != 0)
{
elementsInColumn(elem->column)++;
if (elem->column == row)
number_zeros_on_diagonal_++;
maxRow++;
minRow++;
number_elements_++;
number_equations_per_variable_[elem->column]++;
if (number_elements_ == max_length_int_vector)
OpenSMOKE::FatalErrorMessage("MatrixSparsityPattern::FindDependence(): Too many element dependencies");
elem = elem->next;
}
if (maxRow > max_elements_in_rows_)
{
max_elements_in_rows_ = maxRow;
index_max_row_ = row;
}
if (minRow < min_elements_in_rows_)
{
min_elements_in_rows_ = minRow;
index_min_row_ = row;
}
}
max_elements_in_cols_ = elementsInColumn.Max(&index_max_col_);
min_elements_in_cols_ = elementsInColumn.Min(&index_min_col_);
number_zeros_on_diagonal_ = Min(rows_, columns_) - number_zeros_on_diagonal_;
dependencies_ = new int *[columns_ + 1];
dependencies_[0] = new int[number_elements_ + 1];
dependencies_[1] = dependencies_[0];
int *ptrInt = dependencies_[0] + 1;
int *ivar = new int[columns_ + 1];
memset(ivar, 0, (columns_ + 1)*sizeof(int));
for (int var = 1; var < columns_; var++)
dependencies_[var + 1] = dependencies_[var] + number_equations_per_variable_[var];
for (int row = 1; row <= rows_; row++)
{
elem = element_row_[row];
while (elem != 0)
{
ivar[elem->column]++;
dependencies_[elem->column][ivar[elem->column]] = row;
elem = elem->next;
}
}
delete ivar;
ptrInt = dependencies_[0] + 1;
char *tempFunz = new char[rows_ + 1];
char *tempVar = new char[columns_ + 1];
memset(tempVar, 0, (columns_ + 1)*sizeof(char));
ptr_derivatives_ = new int[columns_ + 1];
int *tempDer = new int[columns_ + 1];
int k;
int ider = 1;
int jder = 1;
int kder;
number_groups_ = 0;
int var;
while (1)
{
memset(tempFunz, 0, (rows_ + 1)*sizeof(char));
for (var = 1; var <= columns_; var++)
if (tempVar[var] == 0)
break;
if (var > columns_)
break;
tempVar[var] = 1;
ptr_derivatives_[ider++] = var;
number_groups_++;
kder = 1;
for (k = 1; k <= number_equations_per_variable_[var]; k++)
tempFunz[dependencies_[var][k]] = 1;
while (1)
{
for (var += 1; var <= columns_; var++)
if (tempVar[var] == 0)break;
if (var > columns_)
{
tempDer[jder++] = kder;
break;
}
char no = 0;
for (k = 1; k <= number_equations_per_variable_[var]; k++)
{
if (tempFunz[dependencies_[var][k]] == 1)
{
no = 1; break;
}
}
if (no == 0)
{
for (k = 1; k <= number_equations_per_variable_[var]; k++)
tempFunz[dependencies_[var][k]] = 1;
tempVar[var] = 1;
ptr_derivatives_[ider++] = var;
kder++;
}
}
}
variable_in_group_ = new int *[number_groups_ + 1];
number_variables_in_group_ = new int[number_groups_ + 1];
var = 0;
for (k = 1; k <= number_groups_; k++)
{
number_variables_in_group_[k] = tempDer[k];
variable_in_group_[k] = &ptr_derivatives_[var];
var += tempDer[k];
}
max_number_of_elements_ = rows_*columns_;
delete tempFunz;
delete tempVar;
delete tempDer;
// Additional analyses
AnalyzeBand();
CalculateDensity();
}
