Beispiel #1
0
  static void test00() {
    Aron.beg();
    PriorityQueue<Interval> queue = new PriorityQueue<Interval>();
    Stack<Interval> stack = new Stack<Interval>();
    int[] arr1 = {4, 1, 2, 6, 9};
    int[] arr2 = {5, 1, 4, 9, 10};

    for (int i = 0; i < arr1.length; i++) {
      queue.add(new Interval(arr1[i], arr2[i]));
    }
    if (queue.size() > 0) {
      stack.push(queue.remove());
    }
    while (!queue.isEmpty()) {
      Interval top = stack.peek();
      Interval inter = queue.remove();
      if (top.end < inter.begin) stack.push(inter);
      else {
        stack.peek().end = Math.max(stack.peek().end, inter.end);
      }
    }
    while (!stack.empty()) {
      System.out.println("[" + stack.peek().begin + " " + stack.peek().end + "]");
      stack.pop();
    }

    Aron.end();
  }
  public void reduce(
      Text key, Iterator<Text> values, OutputCollector<Text, Text> output, Reporter reporter)
      throws IOException {

    while (values.hasNext()) {
      String line = values.next().toString();
      String[] tokens = line.split(",");

      try {
        double latitude = (Double.parseDouble(tokens[2]));
        double longitude = (Double.parseDouble(tokens[3]));

        Tuple t = new Tuple(longitude, latitude, line);
        t.setDistance(fp);
        if (queue.size() < k) {
          queue.add(t);
        } else {
          if (t.distance < queue.peek().distance) {
            queue.add(t);
            queue.remove();
          }
        }

      } catch (Exception c) {

      }
    }

    while (!queue.isEmpty()) {
      output.collect(new Text("1"), new Text(queue.remove().tupleData));
    }
  }
  public void run() {
    synchronized (this) {
      ConnectionState connState;

      while (!Thread.interrupted()) {

        try {

          while (mRetryQueue.isEmpty()) wait();

          connState = mRetryQueue.peek();

          if (!connState.connected) {
            synchronized (connState) {
              long diffTime = connState.nextRetry - System.currentTimeMillis();

              if (diffTime <= 0) {
                mRetryQueue.remove(connState);
                /**
                 * if (!mQuietMode) log.info("Attempting to re-establish " "connection to " +
                 * connState.serviceName + " at " + connState.addr);
                 */
                SendConnectRequest(connState);
              } else {
                wait(diffTime);
              }
            }
          } else mRetryQueue.remove(connState);

        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }
  // O(V) + O(V * V + E) = O(V^2 + E) = O(V^2) if queue is un-ordered linked list
  // O(V * logV) + O(V * logV + E * logV) = O((V + E)logV)
  public static final void dijkstra(DijkVertex[] vertices, DijkVertex src) {

    // Initialize vertices prev and cost (intrinsically done already except for source)
    src.cost = 0;

    // Setup priority queue maintaining min cost vertices at the start of queue
    PriorityQueue<DijkVertex> q =
        new PriorityQueue<DijkVertex>(vertices.length, new DijkVertexComparator());
    q.addAll(Arrays.asList(vertices));

    // Go through queue removing min vertex each iteration
    while (!q.isEmpty()) {
      DijkVertex v = q.remove();

      // If cost of next node is MAX, it is not connected to source
      // Due to priority queue, all nodes after next node are also not connected to source
      // so can just return
      if (v.cost == Integer.MAX_VALUE) {
        return;
      }

      // For each edge leaving vertex, relax
      for (int i = 0; i < v.edges.length; i++) {
        if (v.cost + v.edges[i].cost < v.edges[i].dst.cost) {
          v.edges[i].dst.cost = v.cost + v.edges[i].cost;
          v.edges[i].dst.prev = v;

          // Remove and add updated vertex to queue to place it in correct location
          // after being updated
          q.remove(v.edges[i].dst);
          q.add(v.edges[i].dst);
        }
      }
    }
  }
 public static void main(String[] args) {
   BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   try {
     N = Integer.parseInt(br.readLine());
     P = new int[N][N];
     RP = new boolean[N][N];
     D = new double[N];
     nodes = new HNode[N];
     Fix = new boolean[N];
     String[] chunks;
     for (int i = 0; i < N; i++) {
       chunks = br.readLine().split(" ");
       for (int j = 0; j < N; j++) {
         P[i][j] = Integer.parseInt(chunks[j]);
         if (P[i][j] > 0 && i != j) RP[j][i] = true;
       }
     }
     if (N == 1) {
       System.out.println(0);
       return;
     }
     for (int i = 0; i < N - 1; i++) {
       if (RP[N - 1][i]) {
         D[i] = (double) 100 / (double) P[i][N - 1];
         nodes[i] = new HNode(D[i], i, 1, (1.0 - (double) P[i][N - 1] / (double) 100));
         heap.add(nodes[i]);
       } else {
         D[i] = Double.MAX_VALUE;
         nodes[i] = new HNode(D[i], i, 1, 1);
       }
     }
     HNode minHeap;
     while (!heap.isEmpty()) {
       minHeap = heap.remove();
       if (minHeap.id == 0) {
         System.out.println(minHeap.dis);
         break;
       }
       Fix[minHeap.id] = true;
       for (int j = 0; j < N - 1; j++) {
         if (RP[minHeap.id][j] && !Fix[j]) { // j is the parent of min heap
           double p = (double) P[j][minHeap.id] / (double) 100;
           nodes[j].a = nodes[j].a + nodes[j].b * p * minHeap.dis;
           nodes[j].b = nodes[j].b * (1 - p);
           double newDis = nodes[j].a / (1 - nodes[j].b);
           heap.remove(nodes[j]);
           nodes[j].dis = newDis;
           heap.add(nodes[j]);
         }
       }
     }
   } catch (IOException ioe) {
     ioe.printStackTrace();
   }
 }
 @SuppressWarnings("unchecked")
 @Override
 public boolean remove(Object arg0) {
   try {
     return queue.remove(arg0) && decrement(((Wrapped) arg0).getWrapped());
   } catch (ClassCastException e) {
   }
   try {
     T arg = (T) arg0;
     return queue.remove(new Wrapped(arg)) && decrement(arg);
   } catch (ClassCastException e) {
   }
   return false;
 }
Beispiel #7
0
  private int getMyTarget(int[] shotAt) {

    /*PriorityTuple firstTuple=priorityList.remove();
    if(shotAt[firstTuple.getPlayerId()]>0)
    	return firstTuple.getPlayerId();

    PriorityTuple nextTuple;
    if(priorityList.size()!=0)
    	nextTuple=priorityList.remove();

    while(nextTuple.getPriority()==firstTuple.getPriority())
    {
    	if(shotAt[firstTuple.getPlayerId()]<shotAt[nextTuple.getPlayerId()])
    		return nextTuple.getPlayerId();

    	if(priorityList.size()!=0)
       		nextTuple=priorityList.remove();
    	else
    		break;
    }

    return firstTuple.getPlayerId();*/

    return priorityList.remove().getPlayerId();
  }
 @Override
 public T remove() {
   pruneToDuration();
   T item = queue.remove().getWrapped();
   decrement(item);
   return item;
 }
 private boolean add(TimeWrapped arg0) {
   pruneToDuration();
   if (arg0.getWrapped() == null) return false;
   if (queue.size() >= capacity) {
     try {
       ((CapacityOverflowHandler<T>) continuation)
           .handleCapacityOverflow(queue.remove().getWrapped());
     } catch (NullPointerException e) {
       queue.remove();
     } catch (ClassCastException e) {
       queue.remove();
     }
   }
   increment(arg0.getWrapped());
   return queue.add(arg0);
 }
Beispiel #10
0
 /**
  * moves / increments turn based off of players priority queue
  *
  * @throws IOException exception
  */
 private static void movePhaseTurnIncre() throws IOException {
   if (playerOrder.isEmpty()) {
     for (Player p : Configurations.getPlayers()) {
       playerOrder.add(p);
     }
     Configurations.setRound(Configurations.getRound() + 1);
     if (Configurations.getPhase() == 1) {
       produce();
     }
   }
   Configurations.setCurPlayer(playerOrder.remove());
   if (Configurations.getPhase() != 0) {
     if (Math.random() < .27) {
       Configurations.getCurPlayer().setMessage(applyRandomEvent());
       Configurations.getGameScreenController()
           .updateText(Configurations.getCurPlayer().getMessage());
     } else {
       Configurations.getCurPlayer().setMessage("");
       Configurations.getGameScreenController()
           .updateText(Configurations.getCurPlayer().getMessage());
     }
   } else {
     Configurations.getGameScreenController().updateText();
   }
 }
  private void Loop() {
    while (!H.isEmpty()) {
      Cell v = H.poll();
      if (Log.ON) Log.write("popped: " + potentialField[v.col][v.row]);
      frozenDjogurt[v.col][v.row] = true;
      for (Cell vn : map.doSomeMagic(v)) {
        if (Log.ON) {
          Log.write("\n" + toString(v));
          Log.write("\n" + printStack());
        }
        if (!(map.cells[vn.col][vn.row].type == CellType.OBSTACLE)) {
          if (!frozenDjogurt[vn.col][vn.row]) {
            double d = computeArrivalTime(vn);
            if (d > maxElement) maxElement = d;
            if (!H.contains(vn)) {

              potentialField[vn.col][vn.row] = d;
              H.add(vn);
            } else {
              //							if(potentialField[vn.col][vn.row] > d)
              //							{
              H.remove(vn);
              potentialField[vn.col][vn.row] = d;
              H.add(vn);
              //							}
            }
          }
        }
      }
    }
  }
 public static void main(String[] args) throws IOException {
   int n = readInt();
   int[] dogs = new int[n];
   ArrayList<ArrayList<Integer>> adjlist = new ArrayList<ArrayList<Integer>>();
   for (int x = 0; x < n; x++) {
     dogs[x] = readInt();
     adjlist.add(new ArrayList<Integer>());
   }
   int m = readInt();
   for (int x = 0; x < m; x++) {
     int a = readInt() - 1;
     int b = readInt() - 1;
     adjlist.get(a).add(b);
   }
   int time = readInt();
   int[] bark = new int[n];
   PriorityQueue<Dog> moves = new PriorityQueue<Dog>();
   moves.add(new Dog(0, 0));
   bark[0] = 0;
   int[] total = new int[n];
   while (!moves.isEmpty()) {
     Dog curr = moves.poll();
     if (curr.time > time) continue;
     bark[curr.id] = 0;
     total[curr.id]++;
     for (int x = 0; x < adjlist.get(curr.id).size(); x++) {
       int next = adjlist.get(curr.id).get(x);
       if ((bark[next] != 0 && curr.time + dogs[next] > bark[next])) continue;
       moves.remove(new Dog(next, curr.time + dogs[next]));
       bark[next] = curr.time + dogs[next];
       moves.offer(new Dog(next, curr.time + dogs[next]));
     }
   }
   for (int x : total) System.out.println(x);
 }
 // Busqueda usando A*
 public static int search() {
     HashSet<State> v = new HashSet<>();
     Giros mano = new Giros();
     ArrayList<int[][]>aux;
     
     finall = inicial.createGoalState();
     Q.add(inicial);
     Node actual;
     int cont = 0;
     
     while ( !(actual = Q.remove()).estado.equals(finall.estado) ) {
         
         if(v.contains(actual.estado)) 
             continue;
         System.out.println(actual.estado+" "+actual.costo_hasta_aqui+" "+actual.costo_total);
         System.out.println("->\n"+((NodeCubo)actual).getValue() );
         
         v.add(actual.estado);
         int ca = actual.costo_hasta_aqui + 1;
         
         //Realiza Movimientos
         for( int i=0; i<12; i++ ){
             aux = mano.girar( ((Cubo)actual.getValue()).getCubo(), i);
             Node nuevo = new NodeCubo(ca, ca+Heuristica.h1((Cubo)actual.getValue()), new Cubo( aux, ((Cubo)inicial.getValue()).getColors() ) );
             Q.add( (Node)nuevo );
         }
         cont++;
     }
     return cont;
 }
  public static List<Star> findClosestKStars(int k, ObjectInputStream osin) {
    // maxHeap to store the closest k stars seen so far.
    PriorityQueue<Star> maxHeap = new PriorityQueue<>(k, Collections.reverseOrder());
    try {
      while (true) {
        // Add each star to the max-heap. If the max-heap size exceeds k,
        // remove the maximum element from the max-heap.
        Star star = (Star) osin.readObject();
        maxHeap.add(star);
        if (maxHeap.size() == k + 1) {
          maxHeap.remove();
        }
      }
    } catch (IOException e) {
      // Do nothing, read last element in stream.
    } catch (ClassNotFoundException e) {
      System.out.println("ClassNotFoundException: " + e.getMessage());
    }

    // We cannot go directly to an ArrayList from PriorityQueue, since
    // unlike LinkedList, it does not guarantee ordering of entries.
    List<Star> orderedStars = new ArrayList<Star>(maxHeap);
    // We need to reverse the orderedStars list since it goes from
    // largest to smallest because the PriorityQueue used the
    // Collections.reverse() comparator.
    Collections.reverse(orderedStars);
    return orderedStars;
  }
  /** Implementation of dijkstra's algorithm using a binary heap. */
  private void dijkstra(final PriorityQueue<Vertex> q) {
    Vertex u, v;
    while (!q.isEmpty()) {

      u = q.poll(); // vertex with shortest distance (first iteration
      // will return source)
      // System.out.println("id is"+u.getId());
      // System.out.println(u.getDist());
      // System.out.println(u.getNeighborV().size());
      // System.out.println(this.endNodeId)
      if (u.getDist() == Double.MAX_VALUE)
        break; // we can ignore u (and any other remaining vertices)
      // since they are unreachable

      // look at distances to each neighbor
      for (Map.Entry<Vertex, Double> a : u.getNeighborV().entrySet()) {
        v = a.getKey(); // the neighbor in this iteration

        double alternateDist = u.getDist() + a.getValue();
        if (alternateDist < v.getDist()) { // shorter path to neighbor
          // found
          // System.out.println("+++++");
          q.remove(v);
          v.setDist(alternateDist);
          // System.out.println(v.getId());
          // System.out.println(v.getDist());
          v.setPrevious(u);
          q.add(v);
          // System.out.println(q.size());
        }
      }
    }
  }
 public int[] maxSlidingWindow(int[] nums, int k) {
   if (nums.length == 0 || k == 0) {
     return new int[] {};
   }
   int[] result = new int[nums.length - k + 1];
   PriorityQueue<Integer> priorityQueue =
       new PriorityQueue<Integer>(
           k,
           new Comparator<Integer>() {
             @Override
             public int compare(Integer o1, Integer o2) {
               if (o1 < o2) {
                 return 1;
               } else if (o1 > o2) {
                 return -1;
               } else {
                 return 0;
               }
             }
           });
   Deque<Integer> deque = new LinkedList<Integer>();
   for (int i = 0; i < k; i++) {
     deque.addLast(nums[i]);
     priorityQueue.add(nums[i]);
   }
   for (int i = k; i < nums.length; i++) {
     result[i - k] = priorityQueue.peek();
     int first = deque.removeFirst();
     priorityQueue.remove(first);
     deque.addLast(nums[i]);
     priorityQueue.add(nums[i]);
   }
   result[result.length - 1] = priorityQueue.peek();
   return result;
 }
Beispiel #17
0
  /**
   * gives turns for buying to players
   *
   * @throws IOException exception
   */
  private static void buyTurnIncre() throws IOException {
    if (playerOrder.isEmpty()) {
      for (Player p : Configurations.getPlayers()) {
        if (p.getMoney() > 300 && !p.isPassed()) {
          playerOrder.add(p);
        }
      }
      if (playerOrder.isEmpty()) {
        Configurations.setRound(Configurations.getRound() + 1);

        // Applying random event to player 1 during initial game start
        Configurations.getCurPlayer().setMessage(applyRandomEvent());
        Configurations.getGameScreenController()
            .updateText(Configurations.getCurPlayer().getMessage());
        Configurations.getLoopService().start();
        movePhaseTurnIncre();
        return;
      }
    }
    Configurations.setCurPlayer(playerOrder.remove());
    if (Configurations.getCurPlayer().isPassed()) {
      buyTurnIncre();
    }
    Configurations.getGameScreenController().updateText();
  }
Beispiel #18
0
  public static void computePaths(Vertex source, ArrayList<String> ziel) {
    source.minDistance = 0.;
    PriorityQueue<Vertex> vertexQueue = new PriorityQueue<Vertex>();
    vertexQueue.add(source);
    while (!vertexQueue.isEmpty()) {
      Vertex u = vertexQueue.poll();

      // Visit each edge exiting u
      for (Edge e : u.adjacencies) {
        Vertex v = e.target;
        double weight = e.weight;
        double distanceThroughU = u.minDistance + weight;
        if (distanceThroughU < v.minDistance) {
          vertexQueue.remove(v);
          v.minDistance = distanceThroughU;
          v.previous = u;
          vertexQueue.add(v);
        }
      }
      if (ziel.contains(u.name)) {
        vertexQueue.clear();
        break;
      }
    }
  }
  /** Implements method from {@link IPathFinder}. */
  public List<Point> findPath(Point start, Point end) {
    assertPointIsInBounds(start);
    assertPointIsInBounds(end);

    PriorityQueue<PathNode> openSet = new PriorityQueue<PathNode>();
    Map<Point, PathNode> openSetLookupMap = new HashMap<Point, PathNode>();
    Set<Point> closedSet = new HashSet<Point>();

    PathNode startNode = new PathNode(null, start, 0, context.h(start, end));
    openSet.add(startNode);
    openSetLookupMap.put(startNode.location, startNode);

    while (!openSet.isEmpty()) {
      PathNode current = openSet.remove();
      openSetLookupMap.remove(current.location);

      if (current.location.equals(end)) {
        return reconstructPath(current);
      }

      closedSet.add(current.location);

      for (Point neighbor : findNeighbors(current.location, context.allowDiagonalMovements())) {
        if (!isInValidPoint(neighbor) && !closedSet.contains(neighbor)) {
          PathNode neighborNode = openSetLookupMap.get(neighbor);
          double tentativeGvalue = current.g + context.g_factor(neighbor);

          if (neighborNode == null) {
            neighborNode =
                new PathNode(current, neighbor, tentativeGvalue, context.h(neighbor, end));
          } else {
            neighborNode.g = Math.min(neighborNode.g, tentativeGvalue);
          }

          // TODO modify to use HashSet instead of PriorityQueue since remove is linear anyway
          // TODO the above should allow us to condense two openSets into a single one, replacing
          // openSet.remove() w/ linear time lookup
          // TODO consider inserting things into self sorting data structure, that way remove is
          // constant time and lookups are log n (binary search?)
          openSet.remove(neighborNode);
          openSet.add(neighborNode);
        }
      }
    }

    return new ArrayList<Point>();
  }
Beispiel #20
0
 /** Picks and removes the next entry. Returns null if the entry has been removed. */
 public Entry removeNext() {
   Entry p = pending_queue.remove();
   if (!pending_set.remove(p)) {
     if (logger.isDebugEnabled()) logger.debug("Skipping removed entry " + p);
     return null;
   }
   return p;
 }
  /*skylineII
  * 		// First: split building into two edge and sort
  // Second: create a max-heap with first height 0, we offer height and poll height
  // Third: for every edge, - put in(new skyline), + remove it(old skyline), if current max height not the same as before we add in
  // init 0, max height so far, if change, skyline redraw		//
  * */
  public List<int[]> skylineII(List<Interval> intervals) {
    List<int[]> res = new ArrayList<int[]>();
    if (intervals == null || intervals.size() == 0) {
      return res;
    }
    // First: split building into two edge and sort
    List<int[]> height = new ArrayList<int[]>();
    for (Interval item : intervals) {
      height.add(new int[] {item.start, -item.height}); // start, -height
      height.add(new int[] {item.end, item.height}); // end, height
    }
    Collections.sort(
        height,
        new Comparator<int[]>() {
          public int compare(int[] a, int[] b) {
            if (a[0] != b[0]) return a[0] - b[0];
            return a[1] - b[1]; // start BEFORE end, height small BEFORE height large
            // BOTH START -10,-5=> -10->-5
            // BOTH END 10, 5=>5->10
          }
        });
    // Second: create a max-heap with first height 0, we offer height and poll height
    // 根据position从前到后扫描每一个edge
    // 将edge根据是入还是出来将当前height加入或者移除heap
    // 再得到当前最高点(max-heap)来决定是否加入最终结果。

    // 把所有的turning points 放在一起,根据coordination从小到大sort 。
    // 再用max-heap, 把所有的turning points扫一遍,遇到start turning point,
    // 把 volume放入max-heap.
    // 遇到end turning point,把对应的volume从max-heap中取出。
    // max-heap的max 值就是对应区间的最大volume
    // Input : [2,-10][3,-15][5,-12][7,15][9,10][12,12][15,-10][19,-8][20,10][24,8]
    // Result: [2 10],[3 15],[7 12],[12 0],[15 10],[20 8],[24, 0]
    // Event{true,0,200}, Event{false,10,200}
    // ==> Event{0,200}, Event{10,-200}
    // 按照time排序,time相同,is_in = false的优先
    // 然后你扫过去, is_in=true的你就加mem,is_in=false的你就-mem.每个事件点,
    // 你会加或减一次,每加或减一次后,就check是不是超过总的
    PriorityQueue<Integer> pq = new PriorityQueue<Integer>(10, new pqComparator());
    // Avoid empty heap, still has ZERO value
    pq.offer(0);
    int prev = 0;
    // Third: for every edge, - put in(new skyline), + remove it(old skyline), if current max height
    // not the same as before we add in
    // init 0, max height so far, if change, skyline redraw
    for (int[] item : height) {
      // START, ADD
      if (item[1] < 0) pq.offer(-item[1]);
      // END, REMOVE
      else pq.remove(item[1]);
      int max = pq.peek();
      if (prev != max) {
        res.add(new int[] {item[0], max});
        prev = max;
      }
    }
    return res;
  }
 @Override
 public void decreaseKey(int element, int key) {
   if (key < elements[element].distance) {
     VertexWithDistance updated = new VertexWithDistance(element, key);
     q.remove(updated);
     q.add(updated);
     elements[element] = updated;
   }
 }
Beispiel #23
0
 /**
  * Removes a single instance of the specified element from this queue, if it is present, whether
  * or not it has expired.
  */
 public boolean remove(Object o) {
   final ReentrantLock lock = this.lock;
   lock.lock();
   try {
     return q.remove(o);
   } finally {
     lock.unlock();
   }
 }
Beispiel #24
0
  public void purge() {
    CacheEntry queueEntry = expirationQueue.peek();

    while ((queueEntry != null) && queueEntry.isExpired()) {
      super.remove(queueEntry.getKey());
      expirationQueue.remove();
      queueEntry = expirationQueue.peek();
    }
  }
 public void dijkstra(int src) {
   d[src] = 0;
   pq.add(src);
   while (!pq.isEmpty()) {
     int u = pq.remove();
     for (int i = 1; i <= intersection; i++) {
       if (Matrix[u][i] != 0) relax(u, i, Matrix[u][i]);
     }
   }
 }
Beispiel #26
0
  @Override
  public CacheEntry remove(Object key) {
    CacheEntry entry = super.remove(key);

    if (entry != null) {
      expirationQueue.remove(entry);
    }

    return entry;
  }
 public static String next() {
   if (pq.peek() != null) {
     System.out.println("queue pop");
     String curUrl = pq.remove().url;
     if (!visitedUrl.contains(curUrl)) {
       visitedUrl.add(curUrl);
       return curUrl;
     } else return null;
   } else return null;
 }
Beispiel #28
0
 public static void update(float tpf) {
   if (heap.isEmpty() == false) {
     myTime += (long) (tpf * 1000);
     while (heap.isEmpty() == false && ((Timer) heap.peek()).time < myTime) {
       Timer t = (Timer) heap.peek();
       heap.remove();
       t.execute();
     }
   }
 }
 private void testCustomAggregation(Long[] values, int n) {
   PriorityQueue<Long> heap = new PriorityQueue<Long>(n);
   Arrays.stream(values).filter(x -> x != null).forEach(heap::add);
   Long[] expected = new Long[heap.size()];
   for (int i = heap.size() - 1; i >= 0; i--) {
     expected[i] = heap.remove();
   }
   testAggregation(
       Arrays.asList(expected), createLongsBlock(values), createLongRepeatBlock(n, values.length));
 }
Beispiel #30
0
 public void clearNearestBlockade() throws SOSActionException {
   log.info("clearing NearestBlockade");
   PriorityQueue<Blockade> blockadesInRange =
       model().getBlockadesInRange(agent.me().getX(), agent.me().getY(), agent.clearDistance);
   log.debug("Blockades in Range=" + blockadesInRange);
   Blockade selectedBlock = null;
   if (!blockadesInRange.isEmpty()) selectedBlock = blockadesInRange.remove();
   log.debug("best blockade:" + selectedBlock);
   if (selectedBlock != null) clear(selectedBlock);
 }