Question

k bishops on an nXn chessboard We have previously solved the "N Queens Problem", where, for a given n, we calculated the number of ways to place n queens on an nXn board. This problem concerns "bishops" on the chessboard. What is a bishop? A bishop is a chess piece that controls all the squares on the two diagonals that it can reach Note that a bishop may be either on a white square or a black square. The problenm Write a program that inputs two integers n and k, where n>-k. Your program should calculate the number of different ways that k bishops could be placed on an nXn chessboard Structure your program using the backtracking scheme that we have used for the eight queens problem. What needs to be modified is the "OK" function Input Your main program should loop asking the user for values of n and k. Output Each time through the loop, output n, k and the number of configurations. Program Termination The program will terminate if the user enters a value of-1 for n

The problem

Write a program that inputs two integers n and k, where n>=k. Your program should calculate the number of different ways that k bishops could be placed on an nXn chessboard. Structure your program using the backtracking scheme that we have used for the eight queens problem. What needs to be modified is the “OK” function.

Input

Your main program should loop asking the user for values of n and k.

Output

Each time through the loop, output n, k and the number of configurations. Program Termination The program will terminate if the user enters a value of -1 for n.

Answer 1

Since you have not provided your language preference, I am providing the code in C++

CODE
=================
/*
 Write a program that inputs two integers n and k, where n>=k. Your program should calculate
 the number of different ways that k bishops could be placed on an nXn chessboard.
 Structure your program using the backtracking scheme that we have used for the eight queens
 problem. What needs to be modified is the “OK” function.
 */

#include <cstdlib>
#include <iostream>
using namespace std;

int k, n; //number of bishops, size of the board

//q is an array of squares, where b is a bishop and q[b] is the square the bishop occupies
bool ok(int q[], int b, int n){
    //identify the row and column the bishop is in
    int row = q[b]/n, column = q[b]%n, current_row, current_column;
    
    for(int i=0; i<b; i++){ //for every bishop
        current_row = q[i]/n;
        current_column = q[i]%n;
        
        //diagonal test
        if(abs(row-current_row)==abs(column-current_column)) return false;
    }
    
    return true;
}

void backtrack(int &b, int count){
    b--;
    if(b==-1){
        cout << k << " bishops can be placed on an " << n << " by " << n << " chessboard in " << count << " different ways.";
        exit(1);
    }
}

int vectors(){
    while(true){
        
        //User input
        cout << "Enter n: ";
        cin >> n;
        cout << "Enter k: ";
        cin >> k;
        if(n<0) break;
        
        //Solution/backtracking algorithm
        int* q = new int[k]; //q[bishop] is a square on the n*n grid
        int count = 0, b = 0, t;
        q[b] = 0;
        
        while(true){
            //until we found all the possible solutions
            while(b<k){
                //for each bishop
                
                while(q[b]<n*n){
                    //for each square
                    if(ok(q,b,n)) break;
                    else q[b]++;
                }
                
                if(q[b] == n*n){
                    backtrack(b, count);
                    q[b]++;
                    continue;
                }else{
                    t = q[b];
                    b++;
                    q[b] = t;
                }
            }
            count++;
            backtrack(b, count);
            q[b]++;
        }
    }
    return 0;
}