private void addInterference(IceMap map) {
		
		IceMapSolver solver = new IceMapSolver(map);
		LinkedList<NavigationNode[]> solutions = solver.solve(MOVE_LIMIT, PRUNE_SOLUTION_SET);
		int attempts = 0; 
		
		int lastX = -1;
		int lastY = -1;
		IceMap.Tile lastTile = null;
		
		while(solutions.size() >= 1 && attempts < 1000){

			// Deal with the first solution only
			if(solutions.size() > 0){
				
				NavigationNode[] solution = solutions.get(0);
				
				int maxDistance = 0;
				int selectedMoveIndex = 0;
				
				// Find a move in the optimal solution to interfere with
				for(int i = 0; i < solution.length - 1; i++){
					NavigationNode a = solution[i];
					NavigationNode b = solution[i+1];

					// For the move with that achieves the most distance
					if(this.distance(a, b) > maxDistance){
						maxDistance = this.distance(a, b);
						selectedMoveIndex = i;
					}
				}
				
				if(maxDistance > 1){ // The move must achieve a distance of at least 3 tiles
					
					System.out.println("Interfering with a move of distance " + maxDistance);
					
					NavigationNode a = solution[selectedMoveIndex];
					NavigationNode b = solution[selectedMoveIndex+1];
					
					int x = (a.getDestinationX() + b.getDestinationX())/2;
					int y = (a.getDestinationY() + b.getDestinationY())/2;

					/**/
					if(x == a.getDestinationX()){
						x += random.nextInt(3) - 1;
					}
					else{
						y += random.nextInt(3) - 1;
					}
			
					lastX = x;
					lastY = y;
					lastTile = map.getTileType(x, y);
					
					map.setTileType(x, y, IceMap.Tile.SOLID);
				}
				
			}
			solutions = solver.solve(MOVE_LIMIT, PRUNE_SOLUTION_SET);
			
			if(solutions.isEmpty() && lastTile != null){
				map.setTileType(lastX, lastY, lastTile);
				solutions = solver.solve(MOVE_LIMIT, PRUNE_SOLUTION_SET);
				System.out.println("Reversed last interference");
			}
			
			attempts++;
		}


		
		System.out.println("Attempts: " + attempts);
		
	}