图算法：寻找网络最大流-Ford-Fulkerson算法-js实现

1. 题目

        寻找网络最大流。

 2. 基本思想

        1. 初始化建立Residual Graph

        2. 在Residual Graph中迭代，直至未找到s->t的路径

                a. 寻找一条s->t路径

                b. 找到该路径最大的流量（等于路径上的最小容量）

                c. 更新Residual Graph

                d. 添加回溯路径

3. js代码实现

console.log(Ford_Fulkerson());
// 寻找网络最大流：Ford-Fulkerson算法
function Ford_Fulkerson(){
    v_num=6;
    G=new Array(v_num).fill(0).map(()=>new Array(v_num).fill(0));
    G[0][1]=4;G[0][2]=2;G[1][2]=1;G[1][3]=2;G[2][4]=2;G[1][4]=4;G[3][5]=3;G[4][5]=3;

    ResG=new Array(v_num).fill(0).map(()=>new Array(v_num).fill(0));        // Residual Graph: 用于记录剩余容量
    for(i=0;i<ResG.length;i++){                                             // 二维数组的深度复制
        for(j=0;j<ResG[0].length;j++){
            ResG[i][j]=G[i][j];
        }
    }

    flag=true;                                                              // 标记
    while(flag){                                                            // 起点
        start=0;
        end=v_num-1;                                                        // 终点
        visit=new Array(v_num).fill(-1);                                    // 访问标记
        visit[start]=1;
        dist=-1;                                                            // 路径最小权值

        flag=route(start);                                                  // 寻找路径
        
        function route(node){
            if(node==end){                                                  // 是否为终点
                return true;
            }else{
                flag=false;
                var i;                                                      // 声明局部变量
                for(i=0;i<v_num;i++){
                    if(ResG[node][i]>0&&visit[i]==-1){                      // 是否路径容量大于0且结点i未被访问
                        tmp=dist;                                           
                        if(ResG[node][i]<dist||dist==-1){                   // 更新最小权值
                            dist=ResG[node][i];
                        }
                        visit[i]=1;                                         // 标记访问结点
                        flag=route(i);                                      // 递归调用，寻找下一结点
                        if(flag){                                           // 更新ResG
                            ResG[node][i]-=dist;
                            ResG[i][node]+=dist;
                            break;
                        }else{                                              // 恢复访问状态及权值
                            visit[i]=-1;
                            dist=tmp;
                        }
                    }
                }
                return flag;
            }
        }
    }
    
    flow=0; 
    for(i=0;i<v_num;i++){                                                   // flow=Graph-ResGraph
        flow+=G[0][i]-ResG[0][i];
    }
    return flow;
}