public void edmondsKarp(int start, int target) {
		int n = graph.getKnotenPosition().size();
		int[][] flow = new int[n][n];
		int floxMax = 0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				flow[i][j] = 0;
			}
		}

		// while there exists a path p from s to t in the residual Network Gf
		Graph residualGraph = graph;
		int[][] residualGraphCapacity = residualGraph.getCapacity();
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				residualGraphCapacity[i][j] = graph.getCapacity()[i][j] - flow[i][j];
			}
		}
		//System.out.println("Graph :");
		ArrayList<Position> pos = new ArrayList<Position>();
		Graph g = new Graph(pos, residualGraphCapacity);
		//g.printGraph();

		int[] path = BFS(residualGraphCapacity, start, target);

		while (path != null && !pathList.contains(path)) {
			int capacityPath = getCapacityPath(residualGraphCapacity, path, target, start);
			//System.out.println("capacity path : " + capacityPath );
			floxMax += capacityPath;

			for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					flow[i][j] = 0;
				}
			}
			
			int v = target;
			int u;
			while (v != start) {
				u = path[v];
				//System.out.println("flow : " + u + " , " + v + " : " + capacityPath );
				flow[u][v] = /*flow[u][v] +*/ capacityPath;
				flow[v][u] = /*flow[v][u] */- capacityPath;
				residualGraphCapacity[u][v] = residualGraphCapacity[u][v] - flow[u][v];
				residualGraphCapacity[v][u] -= flow[v][u];
				v = u;
			}
			pathList.add(path);
			//drawGraph(residualGraph, path);
	/*		for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					 ici je pense que c'est plutôt :
					 * residualGraphCapacity[i][j] = graphCapacity[i][j] - flow[i][j];
					 * avec plus haut :
					 * int[][] graphCapacity = residualGraph.getCapacity();
						for (int i = 0; i < n; i++) {
							for (int j = 0; j < n; j++) {
								graphCapacity[i][j] = graph.getCapacity()[i][j];
							}
						}
						parce que sinon si j'ai bien compris ce que t'as écrit la on enleve 
						le nouveau flow mais aussi celui d'avant
						
						ou alors plus simple :
						flow[u][v] = capacityPath;
						flow[v][u] = _capacityPath;
						
						et pareil pour FordFulkerson du coup
 					 
					residualGraphCapacity[i][j] = residualGraphCapacity[i][j] - flow[i][j];
					residualGraphCapacity[j][i] += flow[i][j];
				}
			}
	*/		//System.out.println("Graph :");
			pos = new ArrayList<Position>();
			g = new Graph(pos, residualGraphCapacity);
			//g.printGraph();
			
			path = BFS(residualGraphCapacity, start, target);
		}
		System.out.println("flow Max Edmonds-Karp: " + floxMax);
	}