Question

这基本上是8皇后问题，但在1D阵列中用暴力解决它。假设我有一个大小为8的数组（名为b），其元素范围为0到7。

我使用8个for循环初始化数组中的每个索引，如下所示：

int b[8]={0};

int count = 0;


for(b[0] = 0; b[0]<8; b[0]++){ 
for(b[1] = 0; b[1]<8; b[1]++){ 
for(b[2] = 0; b[2]<8; b[2]++){ 
for(b[3] = 0; b[3]<8; b[3]++){ 
for(b[4] = 0; b[4]<8; b[4]++){ 
for(b[5] = 0; b[5]<8; b[5]++){
for(b[6] = 0; b[6]<8; b[6]++){
for(b[7] = 0; b[7]<8; b[7]++){
                if(check(b)) 
                {
                count++;
                print(b, count);
                }
            }}
        }}
    }}
}}

这个程序应该做的是检查数字0到7的每个组合，并仅在某些条件下返回true。应该有92个解决方案，如果这听起来很熟悉，应该是 - 这是使用暴力的8皇后问题。从这里开始，我理解的是条件：

我希望能够检查数组是否有连续的数字串;如：

[0 | 5 | 7 | 1 | 2 | 3 | 6 | 4]

这里，元素b [3]，b [4]和b [5]是连续的。我不想那样，我想要返回false，因为有一连串的数字（基本上是皇后正在攻击）

我也不希望数组有一串向后连续的数字，如下所示：

[0 | 5 | 7 | 3 | 2 | 1 | 6 | 4]

最后，我不希望在索引中有两个或更多数字，如果我们只是改变它们之间的数字，它会使它们看起来连续：

[0 | 2 | 4 | 6 | 1 | 3 | 5 | 7]

以上是不可接受的，因为b [0]和b [7]是“连续索引”中的数字（因为至少有2个皇后互相攻击）。

[6 | 1 | 3 | 0 | 4 | 7 | 5 | 2]

以上也是不可接受的，因为b [1]和b [4]也在连续索引中。

类似地，当交换值时，数组

[7 | 2 | 4 | 6 | 1 | 3 | 5 | 0]

[6 | 4 | 3 | 0 | 1 | 7 | 5 | 2]

也是不可接受的。我也不能有2个或更多相同的号码。

我遇到的问题是创建检查功能。我被告知我需要使用1 for循环和1 if-then语句。检查功能可以按原样采用整个阵列吗？如果是这样，如何查看数组中最右边的元素，并检查它是否有连续的索引（皇后正在攻击它）？我试过这个：

bool ok(int board[8]){

    for(int c = 7; c >= 0; c--){ //row check
        for (int j=0; j<c; j++){
            if (board[c]==board[j]){
                return false;
            }
        }


        for(int i = 1; i <= c; i++){
            // diagonal check from top left to bottom right
            if  ((board[c]-i >= 0) && (board[c-i] == board[c]-i))
                {return false;}
            if ((board[c]+i <= 7) && (board[c+i] == board[c]+i))
                {return false;}
            // diagonal check from bottom left to top right
            if ((board[c]-i >= 0) && (board[c-i] == board[c]+i))
                {return false;}
            if ((board[c]+i <= 7) && (board[c+i] == board[c]-i))
                {return false;}

        }

    }

    return true;
}

但这不仅不起作用（我得到300多种解决方案），它并不像我应该知道的那么小。

Answer 1

我认为你在对角线上检查碰撞时会遇到一些问题：你的每个方向都有15个对角线（包括角落里非常短的一个方形对角线），而你的代码只检查每个对角线中的七个由于board[c]+i <= 7和board[c]-i >= 0条件。

以下是如何通过使用三个布尔数组来简化检查并使其更快：您有8行，15个上行对角线和15个下行对角线：

bool row[8];
bool ascending[15];
bool descending[15];

最初，这些行/对角线中没有任何皇后。在浏览board的元素时，请执行以下操作：

for (int i = 0 ; i != 8 ; i++) {
    // Check and mark the row
    if (row[board[i]]) return false;
    row[board[i]] = true;
    // Check and mark the ascending diagonal
    int ascIdx = board[i]+i;
    if (ascending[ascIdx]) return false;
    ascending[ascIdx] = true;
    int descIdx = 7+board[i]-i;
    if (descending[descIdx]) return false;
    descending[descIdx] = true;
}
return true;

如何在C ++中查看数组是否有连续数字？

1 个答案: