Maximum Flow

　　Here, I would like to use Ford-Fulkerson Method to determine the Maximum Flow of a given directed graph in the USACO training problem Drainage Ditches:

import java.util.*;
import java.io.*;

public class ditch {
    public static final int INF = (1<<30);
    public static Scanner in;
    public static PrintWriter out;
    public static int num;        // number of vertices
    public static int[][] adjMat;    // residual matrix
    public static int[] path;        // record of augmented path
    public static int len;        // length of augmented path
    
    public static int maxFlow() {
        // Implementation of the Ford-Fulkerson Method
        int val = 0;
        while (genAugPath()) {
            // Whenever an augmented path is discovered
            //        the capacity of it will be added to the flow
            int min = INF;
            for (int i=0;i<len-1;i++) {
                // Determine the capacity of the path
                if (adjMat[path[i+1]][path[i]]<min)
                    min = adjMat[path[i+1]][path[i]];
            }
            for (int i=0;i<len-1;i++) {
                // Modify the residual matrix
                adjMat[path[i+1]][path[i]]-=min;
                adjMat[path[i]][path[i+1]]+=min;
            }
            val += min;
        }
        return val;
    }
    public static boolean genAugPath() {
        // Breadth-First Search for an augmented path
        //        return whether a path has been found
        boolean[] vis = new boolean[num];
        Queue<Integer> q= new LinkedList<Integer>();
        int[] prev = new int[num];
        vis[0] = true;
        q.add(new Integer(0));
        prev[0] = -1;
        while (!q.isEmpty()){
            int k = q.poll().intValue();
            for (int i=1;i<num-1;i++) {
                if (!vis[i]&&adjMat[k][i]>0) {
                    vis[i] = true;
                    q.add(new Integer(i));
                    prev[i] = k;
                }
            }
            if (adjMat[k][num-1]>0) {
                // When destination is reached,
                //        an augmented path is found
                len = 0;
                path[len++] = num-1;
                int idx = k;
                while (idx>=0) {
                    path[len++] = idx;
                    idx = prev[idx];
                }
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) throws IOException{
        in = new Scanner(new FileReader("ditch.in"));
        int n = in.nextInt();
        num = in.nextInt();
        adjMat = new int[num][num];
        for (int i=0;i<n;i++) {
            adjMat[in.nextInt()-1][in.nextInt()-1] += in.nextInt();
        }
        in.close();
        out = new PrintWriter(new FileWriter("ditch.out"));
        path = new int[num];
        out.println(maxFlow());
        out.close();
    }
}