Java实现福特-弗洛克森最大流算法：BFS与DFS搜索路径

import java.util.LinkedList;   
import java.util.Queue;   
import java.util.Scanner;   
  
public class MaxFlow   
{   
  
    private int capacity[][];   
    private int flow[][];   
    private boolean visited[];   
    private int pre[];   
    private int nodes;   
  
    public MaxFlow( int[][] capacity, int nodes )   
    {   
        this.capacity = capacity;   
        this.nodes = nodes;   
        this.flow = new int[nodes][nodes];   
        this.pre = new int[nodes];   
        this.visited = new boolean[nodes];   
    }   
  
    public int maxFlow( int src, int des )   
    {   
        int maxFlow = 0;   
           
        for( int i = 0; i < nodes; i++ )   
            for( int j = 0; j < nodes; j++ )   
                flow[i][j] = 0;   

  
        while( true )//find a augment path   
        {   
            for( int i = 0; i < nodes; i++ )   
            {   
                visited[i] = false;   
            }   
            pre[src] = -1;   
               
            if(!BFS( src, des )){// the BFS    
                break;   
            }   
               
            /*DFS(src,des);//DFS  
            if(!visited[des])  
                break;*/  
               
            int increment = Integer.MAX_VALUE;   
            for( int i = des; pre[i] >= src; i = pre[i] )   
            {   
                //find the min flow of the path   
                increment = Math.min( increment, capacity[pre[i]][i]   
                        - flow[pre[i]][i] );   
            }   
               
            //update the flow   
            for( int i = des; pre[i] >= src; i = pre[i] )   
            {   
                flow[pre[i]][i] += increment;   
                flow[i][pre[i]] -= increment;