有了前面理论的基础，贴代码吧！

1. package com.xh.Dinic;  
2.  
3. import java.util.Arrays;  
4. import java.util.LinkedList;  
5. import java.util.Queue;  
6. import java.util.Stack;  
7.  
8. public class Dinic01 {  
9.     private int[][] capacity;// 容量  
10.     private int[][] flow;// 流量  
11.     private boolean[] visit;// 是否访问  
12.     private int nodes;// 点的个数  
13.     private int[] layers;// 层数  
14.     private int[] pre;  
15.     static int[][]  map={ {
    0,5,4,3,0,0,0,0},//三条边  
16.            {
    0,0,0,0,5,3,0,0},//两条边  
17.              {
    0,0,0,0,0,3,2,0},//两条边   
18.              {
    0,0,0,0,0,0,2,0},//一条边  
19.              {
    0,0,0,0,0,0,0,4},//一条边  
20.               {
    0,0,0,0,0,0,0,3},//一条边   
21.               {
    0,0,0,0,0,0,0,5},//一条边   
22.               {
    0,0,0,0,0,0,0,0}, };  
23.  
24.     public Dinic01(int[][] capacity, int nodes) {  
25.         this.nodes = nodes;  
26.         this.capacity = capacity;  
27.         this.flow = new int[nodes][nodes];  
28.         this.visit = new boolean[nodes];  
29.         this.layers = new int[nodes];  
30.         this.pre = new int[nodes];// 记录路径  
31.     }  
32.  
33.     public boolean layerNetwork(int src, int des) {  
34.         Queue<Integer> queue = new LinkedList<Integer>();  
35.         queue.add(src);  
36.         visit[src] = true;  
37.         layers[src] = 0;  
38.         int node = 0;  
39.         while (!queue.isEmpty()) {  
40.             node = queue.poll();  
41.             for (int i = 0; i < nodes; i++) {  
42.                 if (!visit[i] && capacity[node][i] - flow[node][i] > 0) {  
43.                     queue.add(i);  
44.                     visit[i] = true;  
45.                     layers[i] = layers[node] + 1;  
46.                 }  
47.             }  
48.         }  
49.         if (node == des){  
50.             return true;  
51.         }  
52.         return false;  
53.     }  
54.    
55.     public boolean DFS(int src, int des) {  
56.         Stack<Integer> stack = new Stack<Integer>();  
57.         stack.push(src);  
58.         stack.push(src);  
59.         visit[src] = true;  
60.         int node=src;  
61.         while (!stack.isEmpty()) {  
62.             int i;  
63.             for ( i= 0; i < nodes; i++) {  
64.                 if (!visit[i]&&(layers[i]==layers[node]+1)  
65.                         && capacity[node][i] - flow[node][i] > 0) {  
66.                         stack.push(i);  
67.                         visit[i]=true;  
68.                         pre[i]=node;  
69.                         break;  
70.                 }  
71.             }  
72.             if(i>=nodes){
    //没有点满足情况  
73.                 node=stack.pop();  
74.             }else{  
75.                 node=stack.peek();  
76.             }  
77.             if(node==des){  
78.                 return true;  
79.             }  
80.         }  
81.         return visit[des];  
82.     }  
83.  
84.     public int processAugmentingPaths(int src,int des){  
85.           
86.         int maxflow=0;  
87.             
88.         while (true) {  
89.             Arrays.fill(visit, false);  
90.             pre[src] = -1;  
91.             if (!DFS(src,des)) {
    // the BFS  
92.                 break;  
93.             }  
94.             int increment=Integer.MAX_VALUE;  
95.             for (int i = des; pre[i] >= src; i = pre[i]) {  
96.                 // find the min flow of the path  
97.                 increment = Math.min(increment, capacity[pre[i]][i]  
98.                         - flow[pre[i]][i]);  
99.  
100.             }  
101.             for (int i = des; pre[i] >= src; i = pre[i]) {  
102.                 // find the min flow of the path  
103.                 flow[pre[i]][i]+=increment;  
104.                 flow[i][pre[i]]-=increment;  
105.             }  
106.             maxflow+=increment;  
107.         }  
108.           
109.         return maxflow;  
110.     }  
111.     public int DinicAlgorithm(int src,int des){  
112.         int maxflow=0;  
113.         while (layerNetwork(src, des)) {      
114.             maxflow+=processAugmentingPaths(src, des);  
115.             Arrays.fill(visit, false);  
116.             Arrays.fill(layers, 0);  
117.         }  
118.         return maxflow;  
119.     }  
120.       
121.     public static void main(String[] args) {  
122.         int[][] capacity = new int[map[0].length][map[0].length];  
123.         int nodes = map[0].length;  
124.         for (int i = 0; i < map[0].length; i++) {  
125.             for (int j = 0; j < map[0].length; j++) {  
126.                 if (map[i][j] != 0) {  
127.                     capacity[i][j] = map[i][j];  
128.                 }  
129.             }  
130.         }  
131.         Dinic01 dinic01 = new Dinic01(capacity, nodes);  
132.         System.out.println(dinic01.DinicAlgorithm(0, nodes-1));  
133. //      System.out.println(dinic01.layerNetwork(0, nodes - 1));  
134.     }  
135. }  

尽管代码写出来了，但是我感觉其实依然无法摆脱2F算法的影子。而只是外面披了一层这个算法的皮而已，而其本质好像并没有变化多少……先不去理会那么多了！学习最小费用最大流吧！