陷入 n*n 棋盘上 q 个主教的算法

Question

我使用的是 C++，但我的问题更多是关于算法而不是实现。

问题如下：

编写一个程序，输入两个整数 n 和 k，其中 n>=k。你的程序应该计算出 k 个象可以放在 nXn 棋盘上的不同方式的数量。

我的基本想法是将每个主教表示为具有 X 值和 Y 值的结构。然后我将主教放在板上以获得配置。

我编写了一个名为 moveToNextPlace 的方法，它允许我将主教移动到下一个可用位置。我返回一个字符串来帮助调试。

struct bishop {
int y=0;
int x=0;
string moveToNextPlace (int n){
    if (y<n-1) {y++; return "move to next y value";}
    else if (x<n-1) {x++; return "move to next x value";}
    else {reset(); return "reset";};
}
void setValuesLike (bishop b){
    y=b.y;
    x=b.x;
}
void reset (){
    y=0;
    x=0;
}
bool clashesWith (bishop b){
    if (b.x==x && b.y==y){
        return true;
    }
    if ( b.y-y == b.x-x ) return true; //if their slope is 1
    return false;

}
};

然后我通过使用我想要的设置调用 findSolutions 将板设置为初始配置。

int findSolutions (int k, int n){ //k bishops on n*n board
bishop *b = new bishop [k];
for (int i=0; i<k; i++){
    findAspot (b, n, i);
}
}

bool check (int num, bishop b[]){
for (int i=0 ; i<num; i++){
    if (b[i].clashesWith (b[num])) return false;
}
return true;
}

void findAspot (bishop b[], int n, int num){ //n=boardsize
while (1){
    if (check(num, b)){return;}
    if (b[num].moveToNextPlace(n) == "reset") break;
}
b[num-1].moveToNextPlace(n);
findAspot (b, n, num-1);
b[num].setValuesLike ( b[num-1] );
findAspot (b, n, num);

}

然后我想继续回溯，直到我有一个总数的解决方案，但我被困在如何找到下一个解决方案。

我想我可以编写一个 findNextSolution，它在 findSolutions 函数结束时一直被调用，直到它到达一个循环。但我不知道用什么算法来寻找下一个解决方案。

Answer 1

您将主教职位存储在数组中的想法有了一个良好的开端。这是棋盘状态的简洁表示。

您必须更正检查一位主教是否与另一位主教发​​生冲突的方法。请记住，两个冲突的主教可能被垂直距离dy 和水平距离dx 隔开，这样dx == -dy。因此，您需要比较绝对值：如果abs(dx) == abs(dy)，主教会发生冲突。

现在来解决计算k 主教在不发生冲突的情况下排列的董事会状态数量的一般问题。您需要定义一个返回整数值的函数。假设这个函数看起来像

count(currentBishops, numRemaining)

其中currentBishops 是可行的主教位置，numRemaining 是您尚未放置的主教数量。

那么问题的解决方法就是

count([], k)

[] 表示尚未放置主教。

count函数可以按照如下伪代码实现。

count(currentBishops, numRemaining):
  if numRemaining == 0:
    return 1
  sum = 0
  for each possible board position (x, y):
    if (x, y) does not clash with any bishop in currentBishops:
      let nextBishops be currentBishops augmented with (x, y)
      sum += count(nextBishops, numRemaining-1)
  return sum

为了避免递归调用呈指数级增长，您需要缓存每个子问题的结果。这种技术称为memoization，您可以按如下方式实现它。

let memo be a map from (currentBishops, numRemaining) to an integer value

count(currentBishops, numRemaining):
  if numRemaining == 0:
    return 1
  if memo contains (currentBishops, numRemaining):
    return memo[(currentBishops, numRemaining)]
  sum = 0 
  for each possible board position (x, y):
    if (x, y) does not clash with any bishop in currentBishops:
      let nextBishops be currentBishops augmented with (x, y)
      sum += count(nextBishops, numRemaining-1)
  memo[(currentBishops, numRemaining)] = sum
  return sum

currentBishops 的映射应该是一个不关心你放置主教的顺序的映射。在计算memo 的密钥时，您可以通过对主教位置进行排序或制作棋盘位图来完成此操作。