Java - Ayuda con código *java.lang.ArrayIndexOutOfBoundsException*

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.util.LinkedList;

import java.util.Queue;

public class FordFulkerson1 {

    private int[] padre;

    private Queue<Integer> cola;

    private int numeroVertices;

    private boolean[] visitado;

    public FordFulkerson1(int numeroVertices){

        this.numeroVertices = numeroVertices;

        this.cola = new LinkedList<Integer>();

        padre = new int[numeroVertices + 1];

        visitado = new boolean[numeroVertices + 1];

    }

    public boolean Busqueda(int fuente, int des, int grafo[][]){

        boolean Encontrado = false;

        int destino, elemento;

        for(int vertice = 1; vertice <= numeroVertices; vertice++)

        {

            padre[vertice] = -1;

            visitado[vertice] = false;

        }

        cola.add(fuente);

        padre[fuente] = -1;

        visitado[fuente] = true;

        while (!cola.isEmpty())

        {

            elemento = cola.remove();

            destino = 1;

            while (destino <= numeroVertices)

            {

                if (grafo[elemento][destino] > 0 &&  !visitado[destino])

                {

                    padre[destino] = elemento;

                    cola.add(destino);

                    visitado[destino] = true;

                }

                destino++;

            }

        }

        if(visitado[des])

        {

            Encontrado = true;

        }

        return Encontrado;

    }

    public int fordFulkerson(int grafo[][], int fuente, int destino){

        int u, v;

        int maximoFlujo = 0;

        int pathFlujo;

        int[][] grafoResidual = new int[numeroVertices + 1][numeroVertices + 1];

        for (int fuenteVertice = 1; fuenteVertice <= numeroVertices; fuenteVertice++)

        {

            for (int destinoVertice = 1; destinoVertice <= numeroVertices; destinoVertice++)

            {

                grafoResidual[fuenteVertice][destinoVertice] = grafo[fuenteVertice][destinoVertice];

            }

        }

        while (Busqueda(fuente ,destino, grafoResidual))

        {

            pathFlujo = Integer.MAX_VALUE;

            for (v = destino; v != fuente; v = padre[v])

            {

                u = padre[v];

                pathFlujo = Math.min(pathFlujo, grafoResidual[u][v]);

            }

            for (v = destino; v != fuente; v = padre[v])

            {

                u = padre[v];

                grafoResidual[u][v] -= pathFlujo;

                grafoResidual[v][u] += pathFlujo;

            }

            maximoFlujo += pathFlujo;

        }

        return maximoFlujo;

    }

    public static void main(String args[]){

        int[][] grafo;

        int numberOfNodes = 4;

       int fuente = 0;

        int sink = 3;

        int maximoFlujo;

        String lineas[] = null;

	File archivo = new File("matriz.txt");

                try{

            if(archivo.exists()){

                grafo = new int[4][4];

                BufferedReader bf = new BufferedReader(new FileReader(archivo));

                int Dimencion = 0;

                String Linea = bf.readLine();

                while(Linea != null && Dimencion<4){

                    String[] tmp = Linea.split(" ");

                    for(int x=0;x<4;x++)

                        grafo[Dimencion][x] = Integer.valueOf(tmp[x]);

                    Dimencion++;

                    Linea = bf.readLine();

                }

        FordFulkerson1 fordFulkerson = new FordFulkerson1(numberOfNodes);

        maximoFlujo = fordFulkerson.fordFulkerson(grafo, fuente, sink);

            System.out.println("El flujo maximo es: " + maximoFlujo);

           }

        } catch (IOException ex) {

            System.err.println(ex);

        }

    }

}