Sorry if this post isn't very clear, I'm not think straight right now.
I have been struggling with this Eight Queens assignment and can't seem to understand why the two test BoardState objects display the same board, but differ in conflict count, with only one of them showing the right board with the right amount of conflicts.
Below is the Main class and the BoardState class(the latter being used to keep track of data about a given board).
Any help would be much appreciated.
BoardState Class
package com.company;
import java.util.ArrayList;
import java.util.stream.IntStream;
public class BoardState {
int[][] board;
int[][] boardReverse;
int conflictCount;
public BoardState(int[][]arr){
this.boardReverse=new int[arr[0].length][arr[0].length];
this.board=arr.clone();
for(int i=0;i<arr[0].length;i ){
for(int j=0; j< arr[0].length; j ){
this.boardReverse[i][j]=this.board[arr[0].length-1-i][j];
}
}
this.conflictCount=updateConflictCount();
}
public int updateConflictCount(){
int count=0;
for(int i=0;i<board[0].length;i ){
int rowCount=0;
//horizontal conflict summing
for(int j=0; j<board[0].length; j ){
rowCount =this.board[i][j];
}
count =((rowCount*(rowCount-1))/2);
//front diagonal conflict summing
}
count =diagonalCount();
return count;
}
//adds each sum of the diagonal to an int array
public int diagonalCount(){
int count=0;
int tempSum=0;
int j=0;
int k;
int i=0;
//back diagonals
for(i=0; i< board[0].length; i ){
k=i;
j=i;
i=0;
while(j>=0){
tempSum =this.board[j][i];
j--;
i ;
}
count =(tempSum*(tempSum-1))/2;
tempSum=0;
i=k;
}
for(i=1; i< board[0].length; i ){
k=i;
j=board[0].length-1;
while(i<=board[0].length-1){
tempSum =this.board[j][i];
j--;
i ;
}
count =(tempSum*(tempSum-1))/2;
tempSum=0;
i=k;
}
//front diagonals
for(i=0; i< board[0].length; i ){
k=i;
j=i;
i=0;
while(j>=0){
tempSum =this.boardReverse[j][i];
j--;
i ;
}
count =(tempSum*(tempSum-1))/2;
tempSum=0;
i=k;
}
for(i=1; i< board[0].length; i ){
k=i;
j=board[0].length-1;
while(i<=board[0].length-1){
tempSum =this.boardReverse[j][i];
j--;
i ;
}
count =(tempSum*(tempSum-1))/2;
tempSum=0;
i=k;
}
return count;
}
public int[][] getBoard() {
return board;
}
public void setBoard(int[][] board) {
this.board = board;
}
public int[][] getBoardReverse() {
return boardReverse;
}
public void setBoardReverse(int[][] boardReverse) {
this.boardReverse = boardReverse;
}
public int getConflictCount() {
this.setConflictCount(0);
this.setConflictCount(this.updateConflictCount());
return conflictCount;
}
public void setConflictCount(int conflictCount) {
this.conflictCount = conflictCount;
}
public int[][] copyBoard(int[][] arr){
int[][] copy=new int[arr[0].length][arr[0].length];
for(int i=0;i<arr[0].length; i ){
for(int j=0; j<arr[0].length; j ){
copy[i][j]=arr[i][j];
}
}
return copy;
}
public ArrayList<BoardState> getMoves(){
//get possible moves in each column
ArrayList<BoardState> prospectives= new ArrayList<BoardState>();
prospectives.clear();
int k;
BoardState temp= new BoardState(this.getBoard().clone());
for(int i=0; i<board[0].length; i ){
temp.setBoard(this.copyBoard(this.board));
temp.setConflictCount(this.getConflictCount());
for(k=0; k<board[0].length; k ){
if(board[k][i]==1){
temp.board[k][i]=0;
break;
}
}
for(int j=0; j<board[0].length; j ){
temp.board[j][i]=1;
if(temp.getConflictCount()<this.getConflictCount()){
prospectives.add(new BoardState(temp.getBoard()));
}
temp.board[j][i]=0;
}
temp.board[k][i]=1;
}
return prospectives;
}
}
Main Class
package com.company;
import java.util.Random;
import java.util.ArrayList;
public class Main {
int restarts = 0;
int stateChanges = 0;
static ArrayList<BoardState> NeighborList = new ArrayList<BoardState>();
public void DisplayBoard(int[][] arr) {
for (int i = 0; i < arr.length; i ) {
for (int j = 0; j < arr[0].length; j ) {
System.out.print(arr[i][j] " ");
}
System.out.println();
}
}
public static void initQueens(int[][] arr) {
Random rand = new Random();
for (int i = 0; i < arr[0].length; i ) {
arr[rand.nextInt(8)][i] = 1;
}
}
public static BoardState initBoard(int[][] arr) {
for (int i = 0; i < arr.length; i ) {
for (int j = 0; j < arr[0].length; j ) {
arr[i][j] = 0;
}
}
initQueens(arr);
return new BoardState(arr);
}
public static BoardState findMaxima(BoardState state) {
BoardState using = state;
while (true) {
ArrayList<BoardState> temp = new ArrayList<BoardState>(using.getMoves());
if (temp.size() == 0) {
//send to solution testing
return new BoardState(using.board);
}
System.out.println(using.getConflictCount());
for (int i = 0; i < temp.size(); i ) {
if (temp.get(i).getConflictCount() < using.getConflictCount()) {
using = temp.get(i);
}
}
}
}
public static void main(String[] args) {
// write your code here
Main testObj = new Main();
int[][] board = new int[8][8];
BoardState current = initBoard(board);
BoardState current2 = initBoard(board);
BoardState test = new BoardState(board);
testObj.DisplayBoard(current.board);
System.out.println("Conflicts: " current.updateConflictCount());
System.out.println();
testObj.DisplayBoard(current2.board);
System.out.println("Conflicts: " current2.updateConflictCount());
/* non-debugging code
BoardState finalState;
while (true) {
finalState=findMaxima(current);
if (finalState.getConflictCount()==0) {
break;
}
testObj.restarts ;
System.out.println(testObj.restarts);
current=testObj.initBoard(board);
}
testObj.DisplayBoard(finalState.board);
System.out.println(testObj.stateChanges);
*/
}
}
CodePudding user response：
The problem is that current and current2 use the same array (board). And in initBoard() you set randomly queens. So you first create the board, compute your conflict count, then you overwrite the board and compute another different conflict count and then you print the board twice. But since the original board of current is overwritten you have to identical boards and different conflict count.