我正在编写一个程序,其中我有一个板(3 x 3矩阵),我必须交换特定行和列中的值与其相邻的行和列的逻辑,如果我在[0]处有0值0,0]然后我想要两块板。一个电路板的值为[0,1],[0,1]的值为[0,0],另一个电路板的值为[1,0],[1,0]的值为[0, 0]。但在实现以下代码后,我有两个具有相同值的板,我无法理解这些错误值的任何解释。
编辑:下面我有两个相关的类和相关的方法。问题在于Board类的邻居方法。看来,当我在邻居方法中创建一个电路板时,它不会做它想要做的事情。
BOARD CLASS
public final class Board {
private final int dimen;
private final int[][] blocks;
public Board(int[][] blocks) // construct a board from an N-by-N array of blocks
// (where blocks[i][j] = block in row i, column j)
{
this.dimen = blocks.length;
this.blocks = new int[dimen][dimen];
for (int i = 0; i < dimen; ++i) {
for (int j = 0; j < dimen; ++j) {
this.blocks[i][j] = blocks[i][j];
System.out.println (this.blocks[i][j]);
}
}
...
...
public Iterable<Board> neighbors() // all neighboring boards
{
Stack<Board> neighborStack = new Stack <Board>();
int x = 0, y = 0;
outer : for (int i = 0; i < dimen; ++i){
for (int j = 0; j < dimen; ++j) {
if (this.blocks[i][j] == 0) {
x = i;
y = j;
break outer;
}
}
}
if (x == 0)
{
if (y == 0) {
int tmpBlocks1[][] = Arrays.copyOf (this.blocks, this.blocks.length );
int tmpBlocks2[][] = Arrays.copyOf (this.blocks, this.blocks.length );
tmpBlocks1[0][0] = tmpBlocks1[0][1];
tmpBlocks1[0][1] = 0;
tmpBlocks2[0][0] = tmpBlocks2[1][0];
tmpBlocks2[1][0] = 0;
Board tmpBoard1 = new Board (tmpBlocks1);
neighborStack.push (tmpBoard1);
Board tmpBoard2 = new Board (tmpBlocks2);
neighborStack.push (tmpBoard2);
}
SOLVER CLASS:
public final class Solver {
private MinPQ <SearchNode> pqOriginal;
private MinPQ <SearchNode> pqTwin;
Stack <Board> shortestBoardSequence = null;
int moves = 0;
public Solver(Board initial) // find a solution to the initial board (using the A* algorithm)
{
pqOriginal = new MinPQ<SearchNode>();
pqTwin = new MinPQ<SearchNode>();
pqOriginal.insert(new SearchNode (moves, initial, null) );
pqTwin.insert(new SearchNode (moves, initial.twin(), null) );
}
public boolean isSolvable() // is the initial board solvable?
{
SearchNode originalNode = null;
SearchNode twinNode = null;
Stack <Board> neighborBoards = null;
while (!pqOriginal.isEmpty() || !pqTwin.isEmpty()) {
originalNode = pqOriginal.delMin();
// shortestBoardSequence.push(originalNode.board);
neighborBoards = (Stack<Board>)originalNode.board.neighbors();
...
}
...
}
...
public static void main(String[] args) // solve a slider puzzle (given below)
{
// create initial board from file
In in = new In(args[0]);
int N = in.readInt();
int[][] blocks = new int[N][N];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
blocks[i][j] = in.readInt();
Board initial = new Board(blocks);
// solve the puzzle
Solver solver = new Solver(initial);
// print solution to standard output
if (!solver.isSolvable()) // SEE THE ISSOLVABLE
StdOut.println("No solution possible");
..
}
答案 0 :(得分:4)
这可能是因为你有一个二维数组,而你只复制一个维度。
通过做:
int tmpBlocks1[][] = Arrays.copyOf (blocks, blocks.length );
实际上,您只是复制行引用,而不是行数据。你做的相当于:
int[] row0 = {0,0,0};
int[] row1 = {0,0,0};
int[] row2 = {0,0,0};
int[][] blocks = {row0, row1, row2};
int[][] tmpBlocks1 = {row0, row1, row2};
因此tmpBlocks
与blocks
保持相同的行。
你需要做一个所谓的数组的deep copy
。
演示问题的示例代码:
public final class Test<T> {
int[][] blocks = {{0,1,2},{10,11,12},{20,21,22}};
int[][] copyOfBlocks = Arrays.copyOf(blocks, blocks.length);
int[][] deepCopyOfBlocks = {
Arrays.copyOf(blocks[0], blocks[0].length),
Arrays.copyOf(blocks[1], blocks[1].length),
Arrays.copyOf(blocks[2], blocks[2].length)
};
public void test() {
System.out.println("Before");
System.out.println("Blocks: "+Arrays.deepToString(blocks));
System.out.println("Shallow Copy: "+Arrays.deepToString(copyOfBlocks));
System.out.println("Deep Copy: "+Arrays.deepToString(deepCopyOfBlocks));
// Change blocks and copy and deep copy.
blocks[0][0] = 99;
copyOfBlocks[0][0] = 88;
deepCopyOfBlocks[0][0] = 77;
System.out.println("After");
System.out.println("Blocks: "+Arrays.deepToString(blocks));
System.out.println("Shallow Copy: "+Arrays.deepToString(copyOfBlocks));
System.out.println("Deep Copy: "+Arrays.deepToString(deepCopyOfBlocks));
}
public static void main(String[] args) throws InterruptedException {
try {
Test test = new Test();
test.test();
} catch (Exception e) {
e.printStackTrace();
}
}
}
打印:
Before
Blocks: [[0, 1, 2], [10, 11, 12], [20, 21, 22]]
Shallow Copy: [[0, 1, 2], [10, 11, 12], [20, 21, 22]]
Deep Copy: [[0, 1, 2], [10, 11, 12], [20, 21, 22]]
After
Blocks: [[88, 1, 2], [10, 11, 12], [20, 21, 22]]
Shallow Copy: [[88, 1, 2], [10, 11, 12], [20, 21, 22]]
Deep Copy: [[77, 1, 2], [10, 11, 12], [20, 21, 22]]
请注意,对88的更改被更改为88覆盖,表明副本引用原始行。使用77时,只有深层拷贝受到影响。