Problem with method updating node I don't want it to

[Jim Hester]

A bit of a continuation from this topic, but I've narrowed down the cause to something completely different, but I did put together a SSCCE for this one.

https://coderanch.com/t/511451/java/java/contains-method-PriorityQueue-class

Here's my problem. In the code below, I'm trying to generate successors to a starting node that contains a 9 int array that represents a 9 square puzzle board, with the "0" representing the blank space.

The key method is 'generateSuccessor'. I'm trying to generate all the possible moves (at least 2, up to 4) from a given starting position. In any given puzzle, there can only be one blank space. My problem is that for some reason, when I swap the values of the array, it updates the reference array in the PuzzleNode. Which throws off the second swap, and so on. So I end up with an array with more than 1 zero, which is NOT what I want. I can't figure out how to dereference that array so it just updates my temporary array (swapArray). I've been spinning my wheels on this for a handful of hours now, and I need some help. Thanks!

package gensuccessorstest;

import java.util.PriorityQueue;
import java.util.Comparator;

public class Main {

    public static void main(String[] args) {

        PriorityQueue<PuzzleNode> tempList = new PriorityQueue<PuzzleNode>
            (1,
            new Comparator<PuzzleNode>(){
                public int compare(PuzzleNode a, PuzzleNode b){
                    if (a.getPathCost() > b.getPathCost())
                        return 1;
                    else if (a.getPathCost() < b.getPathCost())
                        return -1;
                    else
                        return 0;
                    }
                }
            );
        PuzzleNode testNode = new PuzzleNode();
        int[] testArray = new int[9];
        // creating a simple array with the same numbers as position in array
        for (int i=0; i<testArray.length; i++){
            testArray[i] = i;
        }
        // set some parameters for the test PuzzleNode
        testNode.setPuzzle(testArray);
        testNode.setDirection("start");
        testNode.setG(0);
        testNode.setH(1);
        testNode.updatePathCost();
        generateSuccessors(testNode, tempList);
    }

        // Should pass in the open list, along the node with the lowest value (next one to search from)
    public static void generateSuccessors(PuzzleNode n, PriorityQueue pq){
        PuzzleNode temp = new PuzzleNode();
        temp = n;
        int[] swapArray = temp.getPuzzle();
        int position = 0;
        // Loop through the array to get the position of the open box
        for (int i = 0; i < temp.getPuzzle().length; i++){
            if (temp.getPuzzle()[i] == 0){
                position = i;
                break;
            }
        }
        // Based on the position of the open box, generate the successor nodes
        if (position == 0){
            // update the node info, add n as a parent, and add to the tempQueue
            swapArray = positionSwap(position, 1, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "right"));
            // reset array to original state
            swapArray = temp.getPuzzle();
            // update for 2nd possible position (from 0)
            swapArray = positionSwap(position, 3, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "down"));
            swapArray = n.getPuzzle();
        } else if (position == 1){
            swapArray = positionSwap(position, 0, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 2, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "right"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 4, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "down"));
        } else if (position == 2) {
            swapArray = positionSwap(position, 1, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 5, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "down"));
        } else if (position == 3){
            swapArray = positionSwap(position, 0, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 4, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "right"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 6, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "down"));
        } else if (position == 4){
            swapArray = positionSwap(position, 1, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 3, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 5, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "right"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 7, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "down"));
        } else if (position == 5){
            swapArray = positionSwap(position, 2, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 4, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 8, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "down"));
        } else if (position == 6){
            swapArray = positionSwap(position, 3, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 6, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "right"));
        } else if (position ==7){
            swapArray = positionSwap(position, 4, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 6, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 8, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "right"));
            swapArray = n.getPuzzle();
        } else if (position == 8){
            swapArray = positionSwap(position, 5, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 7, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "left"));
        }
    }

    public static PuzzleNode createSuccessorNode(int[] puzzle, PuzzleNode n, String direction){
        PuzzleNode newNode = new PuzzleNode(puzzle, n);
        newNode.setH(n.getH());
        newNode.setG(n.getG()+1);
        newNode.updatePathCost();
        newNode.setDirection(direction);
        newNode.printPuzzle(newNode.getPuzzle());
        return newNode;
    }

    public static int[] positionSwap(int blank, int swapInt, int[] array){
        int[] tmp = array;
        tmp[blank] = tmp[swapInt];
        tmp[swapInt] = 0;
        return tmp;
    }

public static class PuzzleNode {
    private int[] puzzleArray;      //representation of the puzzle tiles
    private int hCost;              //represents h(n) in A*
    private int gCost;              //represents g(n) in A*
    private int pathCost;           //represents f(n) in A*
    private PuzzleNode parentNode;  //parent node of the current node
    private String direction;       //tells which direction parent node is

    public PuzzleNode(){
    }

    public PuzzleNode(int[] pArray, PuzzleNode parentNode){
        this.puzzleArray = pArray;
        this.parentNode = parentNode;
    }

    public int[] getPuzzle(){
        return this.puzzleArray;
    }

    public void setPuzzle(int[] puzzleArray){
        this.puzzleArray = puzzleArray;
    }

    public int getPathCost(){
        return this.pathCost;
    }

    public void setPathCost(int pathCost){
        this.pathCost = pathCost;
    }

    public int getH(){
        return this.hCost;
    }

    public void setH(int hCost){
        this.hCost = hCost;
    }

    public int getG(){
        return this.gCost;
    }

    public void setG(int gCost){
        this.gCost = gCost;
    }

    public void updatePathCost(){
        this.pathCost = this.hCost + this.gCost;
    }

    public PuzzleNode getParentNode(){
        return this.parentNode;
    }

    public void setParentNode(PuzzleNode pNode){
        this.parentNode = pNode;
    }

    public void setDirection(String d){
        this.direction = d;
    }

    public String getDirection(){
        return this.direction;
    }

    public void printDirectionChain(){
        PuzzleNode tempNode = this;
        while (tempNode.parentNode != null){
            System.out.print(tempNode.direction + " ");
            System.out.println();
            tempNode = tempNode.parentNode;
        }
    }

    public void printPuzzle(int[] board){
        System.out.println(" ------------- ");
        // Print out the first row
        for (int i=0; i < 3; i++){
            System.out.print(" | " + board[i]);
        }
        System.out.println(" |");
        System.out.println(" ------------- ");
        // Print out the second row
        for (int i=3; i < 6; i++){
            System.out.print(" | " + board[i]);
        }
        System.out.println(" |");
        System.out.println(" ------------- ");
        // Print out the third row
        for (int i=6; i < 9; i++){
            System.out.print(" | " + board[i]);
        }
        System.out.println(" |");
        System.out.println(" ------------- ");
    }
}
}

[David Newton]

Couple of things:

if (a.getPathCost() > b.getPathCost())  
    return 1;  
else if (a.getPathCost() < b.getPathCost())  
    return -1;  
else  
    return 0;  

Shouldn't this be one line of code?

Giant if statement in generateSuccessors: Ew ew ew ew ew.

An SSCCE would really just have the array and swap code: are you working on the original array? It's almost impossible to find the part of the code you're trying to debug.

[Jim Hester]

The problem really lies in this snipped of executing code, particularly in:

swapArray = positionSwap(position, 1, swapArray); 

This is updating 'n' with the new array, when what I really want it to do is to leave 'n' alone, and update swapArray so I can pass that array into a new Node. Make sense? Does posting this snippet of the above code help?

is there a better way of going through the movement options than this giant if statement? I couldn't really think of one, hence this.. I'm still fairly new at this, so any feedback and different ideas are welcome.

        if (position == 0){
            // update the node info, add n as a parent, and add to the tempQueue
            swapArray = positionSwap(position, 1, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "right"));
            // reset array to original state
            swapArray = temp.getPuzzle();
            // update for 2nd possible position (from 0)
            swapArray = positionSwap(position, 3, swapArray);
            pq.add(createSuccessorNode(swapArray, n, "down"));
            swapArray = n.getPuzzle();
        } 

[David Newton]

Jim Hester wrote:This is updating 'n' with the new array, when what I really want it to do is to leave 'n' alone, and update swapArray so I can pass that array into a new Node.

Well, I don't know what "n" is, but that aside: I was asking if you're operating on a single array. If you're passing around a reference to a single array, then there's only one array to operate on, and it's the only one that will be modified. If you want to keep the original array, and operate only on a duplicate (without altering the original), you'd need to copy it.

is there a better way of going through the movement options than this giant if statement?

Almost certainly. The trick is to identify what's the same, and what's different, in each block. From a cursory examination it looks like it's just a couple of indices that change based on the position, leading me to believe that the other numbers could be generated using math.

[Darryl Burke]

BeForthrightWhenCrossPostingToOtherSites
http://www.java-forums.org/new-java/32840-problem-method-updating-node-i-dont-want.html

[Jim Hester]

I appreciate the responses. I created a clone/copy of the array and that method started working like I wanted it to. Now just to fix the others.

I apologize if I offended anyone by cross-posting. I didn't realize there was a code against that, and just wanted to get perspectives of folks that may visit different forums. I'll be forthright about doing so in the future.

[Campbell Ritchie]

Apology accepted
Please tell the people on the other forum you have posted here, too.