Disjoint Sets on finding Path

Question

I am implementing disjoint sets to find if there is a path from a given position in a boolean matrix to the top and the bottom of the matrix. This implementation works, but it is inneficient, as it has ti check the whole top and last rows. Is there any way to make it faster and reducte its time complexity? It has to implement these methods and they will be executed every time a cell changes in the original boolean matrix

public class CeldaDisjunta implements Celda{
    
    int [][] VECINOS = {{-1,-1},{-1,0},{-1,1},
            {0,-1},         {0,1},
            {1,-1},{1,0},{1,1}};
    int n=-1;        
    boolean roto;    
    boolean [][] conductor;
    boolean unioniguales;
    
    
    int ui, uj;
    
    int [] padre;
    int pos;
    
    
    private int getKey (int i, int j) {
        return i*n+j;
    }
    
    
    @Override
    public void Inicializar (int n) {
    //Inicialices the variables     
        if (this.n!=n) {
            this.n=n;
            conductor =new boolean [n][n];
            padre=new int [n*n];
            
        }
        
        for (int i=0;i<n;i++) {
            for (int j=0;j<n;j++) {
                conductor [i][j]=false;
                padre[getKey(i,j)]=getKey(i,j);
            }
        }
        
        
        
        roto=false; //No olvidar
        ui=-1; uj=-1;
    }
    
    @Override
    public void RayoCosmico (int i, int j) {
    //puts the new conductor in the matrix, unions the neighbours and checks if there is a path 
        
        if (conductor[i][j]) { return;}
        int pos= getKey(i,j);
        
        
        ui=i;uj=j;
        conductor[i][j]=true;
        
        
                for (int[] desp:VECINOS) {
                    int ni= i+desp[0];
                    int nj= j+desp[1];
                    if (posValida(ni,nj) && conductor[ni][nj]) {
                        
                        int vecino= getKey(ni,nj);
                        union(pos,vecino);
                    }
                }
        
                
        if (!HayCamino()) { return;}
        roto=true;
        }
        
    
    
    @Override
    public boolean Cortocircuito() { return roto; }
    //Returns if there is a path
    
    public int find(int x) {
        if (padre[x] != x) {
            padre[x] = find(padre[x]);
        }
        return padre[x];
    }

    public void union(int x, int y) {
        padre[find(y)] = find(x);
    }
    
            

     public boolean mismoGrupo(int rx, int ry) {
         return (find(rx)==find(ry));
     }
     
     

    
     public boolean HayCamino() {
//Checks if there is a path. Is a bottleneck
        for(int i=0;i<n;i++) {
            for(int j=0;j<n;j++) {
                int arriba= getKey(0,i);
                int abajo= getKey(n-1,j);
                
                if(mismoGrupo(arriba,abajo)) {
                    return true;
                }
                
            }
            
        }
        return false;
         
     }
     
     public boolean posValida(int i, int j) {
        //Posición en límites
        return (i>=0 && j>=0 && i<n && j<n);
     }
}```