我正试图通过递归来解决数独。该计划运作良好。问题是堆栈只能保持4-6K的递归。这意味着，如果我离开soduku的空单元数超过6-7，那么解决它的组合就是：
4^7 = 16384 > 4-5K...
如何改善程序以减少通话费用？该计划正在解决这个问题。功能：
void solve_soduku(int soduku[][N*N], int &row, int &col, const bool fix_v[][N*N])
是所有业务。
我在这里给你所有正确的soduku所需的数字，以免浪费你的时间。你可以将它们中的一部分看出来，看看它是如何工作的：
0 0 1
0 1 2
0 2 3
0 3 4
1 0 4
1 1 3
1 2 2
1 3 1
2 0 3
2 1 1
2 2 4
2 3 2
3 0 2
3 1 4
3 2 1
3 3 3
-1
和代码：
#include <iostream>
using namespace std;
const int N = 2;
void zero_soduku(int soduku[][N*N]);
void zero_arr(int temp_arr[], int size);
void get_input(int soduku[][N*N], bool fixed_values[][N*N]);
void solve_soduku(int soduku[][N*N], int &row, int &col, const bool fix_v[][N*N]);
bool check_soduku(const int soduku[][N*N]);
bool check_rows(const int soduku[][N*N]);
bool check_cols(const int soduku[][N*N]);
bool check_sub_interval(const int soduku[][N*N]);
void print_soduku(const int soduku[][N*N]);
int main() {
int soduku[N*N][N*N] = { 0 }, row = 0, col = 0;
bool fixed_values[N*N][N*N] = { false };
get_input(soduku, fixed_values);
solve_soduku(soduku, row, col, fixed_values);
cout << endl;
print_soduku(soduku);
system("pause");
return EXIT_SUCCESS;
}
bool check_soduku(const int soduku[][N*N]) {
if (check_rows(soduku) && check_cols(soduku) && check_sub_interval(soduku))
return true;
return false;
}
bool check_rows(const int soduku[][N*N]) {
int temp_arr[N*N] = { 0 };
for (auto i = 0; i < N*N; i++) {
zero_arr(temp_arr, N*N);
for (auto j = 0; j < N*N; j++)
temp_arr[soduku[i][j] - 1]++;
for (auto k = 0; k < N*N; k++)
if (temp_arr[k]>1)
return false;
}
return true;
}
bool check_cols(const int soduku[][N*N]) {
int temp_arr[N*N] = { 0 };
for (auto i = 0; i < N*N; i++) {
zero_arr(temp_arr, N*N);
for (auto j = 0; j < N*N; j++)
temp_arr[soduku[j][i] - 1]++;
for (auto k = 0; k < N*N; k++)
if (temp_arr[k]>1)
return false;
}
return true;
}
bool check_sub_interval(const int soduku[][N*N]) {
int temp_arr[N*N] = { 0 };
for (auto rows_intervals = 0; rows_intervals < N; rows_intervals++)
for (auto cols_intervals = 0; cols_intervals < N; cols_intervals++)
for (auto i = rows_intervals*N; i < rows_intervals*N + N; i++)
for (auto j = cols_intervals*N; j < cols_intervals*N + N; j++) {
temp_arr[soduku[i][j] - 1]++;
//end of interval, check if !good interval
if (i == rows_intervals*N + N - 1 && j == cols_intervals*N + N - 1) {
for (auto k = 0; k < N*N; k++)
if (temp_arr[k]>1)
return false;
zero_arr(temp_arr, N*N);
}
}
return true;
}
void solve_soduku(int soduku[][N*N], int &row, int &col, const bool fix_v[][N*N]) {
static int counter = 0;
counter++;
cout << endl << counter << endl;
//Not empty cell
if (soduku[row][col] != 0)
//Not end of line
if (col < N*N - 1) {
col++;
solve_soduku(soduku, row, col, fix_v);
}
else
//Not end of rows
if (row < N*N - 1) {
row++;
col = 0;
solve_soduku(soduku, row, col, fix_v);
}
else
//end of soduku
if (check_soduku(soduku)) {
print_soduku(soduku);
return;
}
/////// Finishd soduku but answaer not good //////////////////
else
//Last cell not max
if (soduku[row][col] < N*N - 1) {
soduku[row][col]++;
print_soduku(soduku);
cout << endl;
solve_soduku(soduku, row, col, fix_v);
}
//Last cell max, going back...
else {
while (soduku[row][col] == N*N || fix_v[row][col]) {
if (!fix_v[row][col]) {
soduku[row][col] = 1;
print_soduku(soduku);
cout << endl;
}
if (col > 0) {
col--;
continue;
}
if (col == 0 && row > 0) {
col = N*N - 1;
row--;
}
}
if (!fix_v[row][col]) {
soduku[row][col]++;
print_soduku(soduku);
cout << endl;
}
solve_soduku(soduku, row, col, fix_v);
}
//////////////////////////////////////////////////////////////////////////
//Empty cell
else {
soduku[row][col]++;
print_soduku(soduku);
cout << endl;
solve_soduku(soduku, row, col, fix_v);
}
}
void zero_arr(int temp_arr[], int size) {
for (auto i = 0; i < size; i++)
temp_arr[i] = 0;
}
void zero_soduku(int soduku[][N*N]) {
for (int i = 0; i < N*N; i++)
for (int j = 0; j < N*N; j++)
soduku[i][j] = 0;
}
void get_input(int soduku[][N*N], bool fixed_values[][N*N]) {
cout << endl << "Please enter locatin and nums into soduku: ";
int row = 0, col, value;
while (row != -1) {
cin >> row;
if (row == -1)
return;
cin >> col >> value;
soduku[row][col] = value;
fixed_values[row][col] = true;
}
}
void print_soduku(const int soduku[][N*N]) {
for (auto i = 0; i < N*N; i++)
for (auto j = 0; j < N*N; j++) {
cout << soduku[i][j] << " ";
if (j == N*N - 1)
cout << endl;
}
//system("pause");
}`enter code here`
答案 0 :(得分：2)
您的算法大概是：
1）依次尝试每一步
2）检查整个电路板是否有效
3）重复直到整个电路板都已填满
这显然效率很低。代码将会做出许多违法行为，然后事后才意识到这一点。
我建议你完全摆脱这一点，并试图实现一些更高效的东西。尝试思考基于碳的生命形式如何解决数独难题，并实施相同的算法。当你解决数独谜题时，你也做了上述方法吗？当然不是。你做这样的事情：
1）对于棋盘上的每个位置，而不是仅存储该位置的当前号码（如果有的话），还存储其他信息：即，如果该位置没有号码，也存储所有可能合法的号码移动到那个位置。
例如，对于一个完全空的板，数独板上的每个位置都将包含所有值1-9。然后，我们进行下一个合乎逻辑的步骤：
2）当移动并将值放在某个位置（例如4）时，您将从其3x3平方中的所有其他单元格中删除值4，并从同一行和列中的所有其他单元格中删除4。因为该数字将不再是这些单元格中的有效移动。相反，当撤消移动并从单元格中移除4时，这意味着值4现在在其3x3方格及其行和列的所有单元格中都是合法的，因此您可以将此值放在所有这些位置中，作为一个现在在这些职位上合法行动的数字。
3）在决定下一步做什么时，首先扫描电路板，寻找只有一个可能合法号码的电池。当然，这意味着这是该单元格的唯一合法行动，因此您可以实现。
4）如果您发现任何没有合法值的单元格，这意味着您已达到无法解决的状态，因此您将撤消上次移动，然后尝试从该点开始的下一个有效移动。
5）否则，您应该选择剩下合法移动最少的一个单元格，先进行移动，然后继续前进，然后如果达到无法解决的状态，然后返回此移动，则撤消它，并尝试下一步行动。
在我看来，这种方法应该更有效率，因为它最终会导致非法移动次数最少。
它也非常模仿碳基生命形式如何自己解决数独难题。
P.S。要使用预先填充的数字初始化一个新的数独谜题，只需从一个空的数独板开始，所有单元格允许所有数字1-9作为合法移动，然后如上所述进行每次移动以填充数独板上的初始数字