problema crear sucesores

Buenas tardes, tengo un problema con una práctica. El problema está en que una de las clases que tengo implementadas, llamada espacio de estado, tiene un metodo sucesores que que toma como parámetro una matriz de enteros, y esta, a partir de la posición '0'(la matriz estará desordenada en principio), debe crear hijos con los posibles movimientos que pueda realizar.
Por ejemplo, supongamos que tenemos una matriz de 3x3 y tenemos el '0' en la posición
[1][2], pues podrá realizar movimientos hacia arriba, hacia abajo y hacia la izquierda.
La cosa es que si llamo al metodo sucesores en la clase main y le meto una matriz de enteros desordenada por parámetros, me crea el primer sucesor bien, pero a partir de ese me los crea a partir de la matriz modificada, y no a partir de la matriz que metí por parámetro.
No sé si me estoy explicando bien. Es decir, que la matriz 'estado' en este caso se modifica, cuando no se tendrá que modificar.
Adjunto código de la clase a ver si me podeis resolver la duda.

Código:

package Puzzle;

import java.util.ArrayList;

import java.util.Arrays;

public class Estado {
	
	
	//public Estado(){
	//}
	
	public boolean esObjetivo(int [][] estadoactual){
		int cont1=0;
		int [][] objetivo = new int[estadoactual.length][estadoactual[0].length];
		for(int i = 0; i < estadoactual.length; i++){//Creamos la matriz de la solucion: 0,1,2,3,4,5,6...etc
			for(int j=0; j < estadoactual[0].length; j++){
				estadoactual[i][j]=cont1;
				cont1++;
			}
		}
		return Arrays.equals(estadoactual, objetivo);//Si son iguales true, si no false
	}
	
	public int[] obtenerNegra(int [][] actual){
		int[] posiciones=new int[2];
		for(int i=0; i<actual.length;i++){
			for(int j=0; j<actual[0].length; j++){
				if(actual[i][j]==0){
				posiciones[0]=i;
				posiciones[1]=j;
				}
			}
		}
		return posiciones;
	}
	
	public ArrayList<int [][]> Sucesores(int [][] estado){
		ArrayList<int [][]> sucesores = new ArrayList<int [][]>();
		int [][] estfinal = new int[estado.length][estado[0].length];
		int [] posicionesNegra= obtenerNegra(estfinal);
		ArrayList<Integer> lmv = mvmValidos(estfinal, posicionesNegra[1], posicionesNegra[0]);
    	for(int i =0; i < lmv.size(); i++){
    		estfinal=estado;
    		int [][] nuevaMatriz = mover(estfinal, lmv.get(i),posicionesNegra[1] , posicionesNegra[0]); // Matriz actualizada con el movimiento realizado
    		//ArrayList<int [][]> nuevaLista = new ArrayList<int [][]>();
    		prinstate(nuevaMatriz);
    		sucesores.add(nuevaMatriz);
    	}
    	return sucesores;
	}
	
	public int [][] mover(int [][] estadoact,int movimientos, int ynegra, int xnegra){
		int [][] nm = new int[estadoact.length][estadoact[0].length];//Nueva matriz para aplicar el movimiento
		nm=estadoact;
		int aux=0;
    		if(movimientos==3){ // Mueve hacia la izquierda (Left)
            	aux=nm[xnegra][ynegra];
            	nm[xnegra][ynegra]= nm[xnegra][ynegra-1];
            	nm[xnegra][ynegra-1]= aux;
    		}
            if(movimientos==2){ // Mueve hacia la derecha (Right)
            	aux=nm[xnegra][ynegra];
            	nm[xnegra][ynegra]= nm[xnegra][ynegra+1];
            	nm[xnegra][ynegra+1]= aux;
            }
            if(movimientos==1){ // Mueve hacia abajo (Down)
            	aux=nm[xnegra][ynegra];
            	nm[xnegra][ynegra]= nm[xnegra+1][ynegra];
            	nm[xnegra+1][ynegra]= aux;
            }
            if(movimientos==0){ // Mueve hacia arriba (Up)
            	aux=nm[xnegra][ynegra];
            	nm[xnegra][ynegra]= nm[xnegra-1][ynegra];
            	nm[xnegra-1][ynegra]= aux;
            }
            

    	return nm;
	}
	
	public void prinstate(int [][] estadoactual){
		String estado="";
		for(int i=0;i<estadoactual.length;i++){
			for(int j=0; j < estadoactual.length; j++){
				estado = estado + Integer.toString(estadoactual[i][j])+" ";
			}
		}
		System.out.println(estado);
	}
	
	public ArrayList<Integer> mvmValidos(int [][] estadoactual, int ynegra, int xnegra){ // Este metodo devuelve una lista con los movimientos validos del cuadro "Vacio(negro)".
        ArrayList<Integer> movimientos=new ArrayList<Integer>();
       movimientos.add(0);//up 
       movimientos.add(1);//down
       movimientos.add(2); //right	
       movimientos.add(3);//left
        
		if(ynegra==0){ // Segun en que parte del puzzle se encuentre se eliminaran los posibles movimientos para que en la lista solo queden los validos.
			movimientos.remove(3); //Left
		}
		if(ynegra==estadoactual[0].length-1){
			movimientos.remove(2); //Rigth
		}
        if(xnegra==0){
             movimientos.remove(0);//Up
        }
        if(xnegra==estadoactual.length-1){
            movimientos.remove(1); //Down
        }      	
        return movimientos;
	}

	
	
	
}

Gracias!!