public static void main(String args[]) throws IOException { String text = "C:\\Users\\Roshan Rajan\\Desktop\\squaredance.txt"; String gender = ""; PriorityQueue<String> men = new PriorityQueue<String>(); PriorityQueue<String> women = new PriorityQueue<String>(); BufferedReader input = new BufferedReader(new FileReader(text)); String line = null; while ((line = input.readLine()) != null) { gender = line.substring(0, 1); if (gender.equals("M")) men.add(line.substring(2)); else women.add(line.substring(2)); } input.close(); while (!men.isEmpty() && !women.isEmpty()) { System.out.println("The couples are "); System.out.println(men.poll() + " is Dancing with " + women.poll()); } if (men.isEmpty()) { System.out.println(women.size() + " girls are Waiting to Dance"); System.out.println(women.peek() + " is the first one waiting"); } if (women.isEmpty()) { System.out.println(men.size() + " guys are Waiting to Dance"); System.out.println(men.peek() + " is the first one waiting"); } }
/** * Retrieves and removes the head of this queue, waiting if necessary until an element with an * expired delay is available on this queue. * * @return the head of this queue * @throws InterruptedException {@inheritDoc} */ public E take() throws InterruptedException { final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { for (; ; ) { E first = q.peek(); if (first == null) available.await(); else { long delay = first.getDelay(TimeUnit.NANOSECONDS); if (delay <= 0) return q.poll(); else if (leader != null) available.await(); else { Thread thisThread = Thread.currentThread(); leader = thisThread; try { available.awaitNanos(delay); } finally { if (leader == thisThread) leader = null; } } } } } finally { if (leader == null && q.peek() != null) available.signal(); lock.unlock(); } }
/** * Retrieves and removes the head of this queue, waiting if necessary until an element with an * expired delay is available on this queue, or the specified wait time expires. * * @return the head of this queue, or <tt>null</tt> if the specified waiting time elapses before * an element with an expired delay becomes available * @throws InterruptedException {@inheritDoc} */ public E poll(long timeout, TimeUnit unit) throws InterruptedException { long nanos = unit.toNanos(timeout); final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { for (; ; ) { E first = q.peek(); if (first == null) { if (nanos <= 0) return null; else nanos = available.awaitNanos(nanos); } else { long delay = first.getDelay(TimeUnit.NANOSECONDS); if (delay <= 0) return q.poll(); if (nanos <= 0) return null; if (nanos < delay || leader != null) nanos = available.awaitNanos(nanos); else { Thread thisThread = Thread.currentThread(); leader = thisThread; try { long timeLeft = available.awaitNanos(delay); nanos -= delay - timeLeft; } finally { if (leader == thisThread) leader = null; } } } } } finally { if (leader == null && q.peek() != null) available.signal(); lock.unlock(); } }
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; }
public double getMedian() { if (smallerElements.size() == largerElements.size()) { return (smallerElements.peek() + largerElements.peek()) / 2.0; } else { return largerElements.peek(); } }
public void purge() { CacheEntry queueEntry = expirationQueue.peek(); while ((queueEntry != null) && queueEntry.isExpired()) { super.remove(queueEntry.getKey()); expirationQueue.remove(); queueEntry = expirationQueue.peek(); } }
public Integer findMedian() { if (min.size() < max.size()) { return max.peek(); } else if (max.size() < min.size()) { return min.peek(); } else { return ((max.peek() + min.peek()) / 2); } }
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(); } } }
public int minMeetingRooms(Interval[] intervals) { Arrays.sort(intervals, new IntervalComparator()); PriorityQueue<Integer> roomQueue = new PriorityQueue<Integer>(); int num = 0; for (int i = 0; i < intervals.length; i++) { if (roomQueue.isEmpty()) { num++; System.out.println(intervals[i].end); roomQueue.offer(intervals[i].end); } else { int minEnd = roomQueue.peek(); System.out.println("minEnd: " + minEnd); if (intervals[i].start < minEnd) { System.out.println("new offering " + intervals[i].end); num++; roomQueue.offer(intervals[i].end); } else { System.out.println("substitude " + intervals[i].end); roomQueue.poll(); roomQueue.offer(intervals[i].end); } } } return num; }
public void solve(int testNumber, InputReader in, OutputWriter out) { String X; PriorityQueue<Integer> pq = new PriorityQueue<>(); Stack<Integer> stack = new Stack<>(); while ((X = in.next()) != null) { int x = Integer.valueOf(X); pq.add(x); int sz = pq.size(); int median = 0; if (sz == 1) { median = pq.peek(); } else { for (int i = 0; i <= sz / 2; i++) { stack.add(pq.poll()); if ((i == (sz / 2) - 1 && sz % 2 == 0) || i == (sz / 2)) { median += stack.peek(); } } if (sz % 2 == 0) median /= 2; } while (!stack.isEmpty()) pq.add(stack.pop()); out.printLine(median); } }
private HeightEvent nextEvent() { EdgeCollision ec; for (; ; ) { ec = faceEvents.poll(); if (ec == null) break; // valid if we haven't seen it, and it's height is "greater" than // the current skeleton height if (!skel.seen.contains(ec) && ec.loc.z - skel.height > -0.001) break; } HeightEvent he = miscEvents.peek(); if (ec == null) { return miscEvents.poll(); // might be null! } if (he == null) { skel.seen.add(ec); return ec; // might be null! } if (he.getHeight() <= ec.getHeight()) { faceEvents.add(ec); return miscEvents.poll(); // return he } else { skel.seen.add(ec); return ec; // return ec } }
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)); } }
private void assertMinimumsAreEqual( java.util.PriorityQueue<Integer> oldQueue, PriorityQueue<Integer> newQueue) { assertThat(oldQueue.isEmpty()).isEqualTo(newQueue.isEmpty()); if (!newQueue.isEmpty()) { assertThat(oldQueue.peek()).isEqualTo(newQueue.head()); } }
/** * Retrieves and removes the head of this queue, waiting if necessary until an element with an * expired delay is available on this queue, or the specified wait time expires. * * @return the head of this queue, or <tt>null</tt> if the specified waiting time elapses before * an element with an expired delay becomes available * @throws InterruptedException {@inheritDoc} */ public E poll(long timeout, TimeUnit unit) throws InterruptedException { long nanos = unit.toNanos(timeout); final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { for (; ; ) { E first = q.peek(); if (first == null) { if (nanos <= 0) return null; else nanos = available.awaitNanos(nanos); } else { long delay = first.getDelay(TimeUnit.NANOSECONDS); if (delay > 0) { if (nanos <= 0) return null; if (delay > nanos) delay = nanos; long timeLeft = available.awaitNanos(delay); nanos -= delay - timeLeft; } else { E x = q.poll(); assert x != null; if (q.size() != 0) available.signalAll(); return x; } } } } finally { lock.unlock(); } }
/** The sensor manager determines what all of the sensors are able to confirm. */ @Override public Environment apply(Environment t) { /* * If we have any omniscient sensors, they will be the first sensor on * the list. */ Sensor firstSensor = sensors.peek(); if (firstSensor instanceof OmniscientSensor) { return firstSensor.apply(t); } /* * Otherwise, extract the different types of sensor */ LinkedList<ProximitySensor> proximitySensors = new LinkedList<>(); for (Sensor sensor : sensors) { if (sensor instanceof ProximitySensor) { proximitySensors.add((ProximitySensor) sensor); } } /* * If we have no other sensors, throw a problem */ if (proximitySensors.size() == 0) { throw new RuntimeException("Sensor was not omniscient!"); } return proximitySensors.getFirst().apply(t); }
/** * Evaluates a query. * * @param queryTree A query tree that has been already transformed with * StructuredRetrieval.transformQuery. * @param requested The number of documents to retrieve, at most. * @return * @throws java.lang.Exception */ public ScoredDocument[] runQuery(Node queryTree, int requested) throws Exception { // my addition queryTree = this.transformQuery(queryTree); // System.out.println("runQuery: " + queryTree.toString()); // construct the query iterators ScoreIterator iterator = (ScoreIterator) createIterator(queryTree); // now there should be an iterator at the root of this tree PriorityQueue<ScoredDocument> queue = new PriorityQueue<ScoredDocument>(); while (!iterator.isDone()) { int document = iterator.nextCandidate(); int length = index.getLength(document); double score = iterator.score(document, length); if (queue.size() <= requested || queue.peek().score < score) { ScoredDocument scoredDocument = new ScoredDocument(document, score); queue.add(scoredDocument); if (queue.size() > requested) { queue.poll(); } } iterator.movePast(document); } return getArrayResults(queue); }
protected List<InputSplit> combineSplits( PriorityQueue<LuceneIndexInputSplit> splits, long maxCombinedIndexSizePerSplit, long maxNumIndexesPerSplit) { // now take the one-split-per-index splits and combine them into multi-index-per-split splits List<InputSplit> combinedSplits = Lists.newLinkedList(); LuceneIndexInputSplit currentSplit = splits.poll(); while (currentSplit != null) { while (currentSplit.getLength() < maxCombinedIndexSizePerSplit) { LuceneIndexInputSplit nextSplit = splits.peek(); if (nextSplit == null) { break; } if (currentSplit.getLength() + nextSplit.getLength() > maxCombinedIndexSizePerSplit) { break; } if (currentSplit.getIndexDirs().size() >= maxNumIndexesPerSplit) { break; } currentSplit.combine(nextSplit); splits.poll(); } combinedSplits.add(currentSplit); currentSplit = splits.poll(); } return combinedSplits; }
public HeightEvent poll() { currentCoHeighted = null; // now working at a new height HeightEvent next = nextEvent(); if (next instanceof EdgeCollision) { List<EdgeCollision> coHeighted = new ArrayList<EdgeCollision>(); EdgeCollision ec = (EdgeCollision) next; coHeighted.add(ec); double height = ec.getHeight(); for (; ; ) { EdgeCollision higher = faceEvents.peek(); if (higher == null) break; if (higher.getHeight() - height < 0.00001) // ephemeral random // constant #34 was // 0.00001 { faceEvents.poll(); // same as higher if (skel.seen.contains(higher)) continue; height = higher.getHeight(); skel.seen.add(higher); coHeighted.add(higher); } else break; } return currentCoHeighted = new HeightCollision(coHeighted); } else return next; }
@Override public CategoricalResults classify(DataPoint data) { CategoricalResults cr = new CategoricalResults(predicting.getNumOfCategories()); // Use a priority que so that we always pick the two lowest value class labels, makes indexing // into the oneVsOne array simple PriorityQueue<Integer> options = new PriorityQueue<Integer>(predicting.getNumOfCategories()); for (int i = 0; i < cr.size(); i++) options.add(i); CategoricalResults subRes; int c1, c2; // We will now loop through and repeatedly pick two combinations, and eliminate the loser, until // there is one winer while (options.size() > 1) { c1 = options.poll(); c2 = options.poll(); subRes = oneVone[c1][c2 - c1 - 1].classify(data); if (subRes.mostLikely() == 0) // c1 wins, c2 no longer a candidate options.add(c1); else // c2 wins, c1 no onger a candidate options.add(c2); } cr.setProb(options.peek(), 1.0); return cr; }
/** * Adds {@code value} to this heap if it is larger than any of the current elements. Returns * {@code true} if {@code value} was added. */ private boolean maybeAddInput(T value) { if (maximumSize == 0) { // Don't add anything. return false; } // If asQueue == null, then this is the first add after the latest call to the // constructor or asList(). if (asQueue == null) { asQueue = new PriorityQueue<>(maximumSize, compareFn); for (T item : asList) { asQueue.add(item); } asList = null; } if (asQueue.size() < maximumSize) { asQueue.add(value); return true; } else if (compareFn.compare(value, asQueue.peek()) > 0) { asQueue.poll(); asQueue.add(value); return true; } else { return false; } }
/** * Get top N elements * * @param vec the vec to extract the top elements from * @param N the number of elements to extract * @return the indices and the sorted top N elements */ private static List<Double> getTopN(INDArray vec, int N) { ArrayComparator comparator = new ArrayComparator(); PriorityQueue<Double[]> queue = new PriorityQueue<>(vec.rows(), comparator); for (int j = 0; j < vec.length(); j++) { final Double[] pair = new Double[] {vec.getDouble(j), (double) j}; if (queue.size() < N) { queue.add(pair); } else { Double[] head = queue.peek(); if (comparator.compare(pair, head) > 0) { queue.poll(); queue.add(pair); } } } List<Double> lowToHighSimLst = new ArrayList<>(); while (!queue.isEmpty()) { double ind = queue.poll()[1]; lowToHighSimLst.add(ind); } return Lists.reverse(lowToHighSimLst); }
// Time: O(n*logk) // Space: O(k) // Use min heap to store current end time of each room. // If current interval start time is smaller than the minimum end time, // create a new room (add end time to the heap) // Else, update the minimum end time // Return the size of heap public int minMeetingRooms(Interval[] intervals) { if (intervals == null || intervals.length == 0) return 0; Arrays.sort( intervals, new Comparator<Interval>() { @Override public int compare(Interval i1, Interval i2) { return i1.start - i2.start; } }); PriorityQueue<Integer> heap = new PriorityQueue<Integer>(); for (Interval interval : intervals) { if (heap.size() == 0) { heap.offer(interval.end); } else { if (interval.start < heap.peek()) { heap.offer(interval.end); } else { heap.poll(); heap.offer(interval.end); } } } return heap.size(); }
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(); } } } }
@Override public synchronized List<T> getTopK() { Comparator<T> comparator = new Comparator<T>() { public int compare(T key1, T key2) { return Longs.compare(counts.get(key1), counts.get(key2)); } }; PriorityQueue<T> topK = new PriorityQueue<T>(k, comparator); for (Map.Entry<T, Long> entry : counts.entrySet()) { if (topK.size() < k) { topK.offer(entry.getKey()); } else if (entry.getValue() > counts.get(topK.peek())) { topK.offer(entry.getKey()); topK.poll(); } } LinkedList<T> sortedTopK = new LinkedList<T>(); while (!topK.isEmpty()) { sortedTopK.addFirst(topK.poll()); } return sortedTopK; }
public T receive() { lock.lock(); try { while (true) { DelayedMessage message = queue.peek(); if (message == null && stopping) { return null; } if (message == null) { condition.await(); continue; } long now = timeProvider.getCurrentTime(); if (message.dispatchTime > now) { condition.awaitUntil(new Date(message.dispatchTime)); } else { queue.poll(); if (queue.isEmpty()) { condition.signalAll(); } return message.message; } } } catch (InterruptedException e) { throw UncheckedException.throwAsUncheckedException(e); } finally { lock.unlock(); } }
@Override public int next() { long start = System.currentTimeMillis(); if (currentDocId == Constants.EOF) { return currentDocId; } while (queue.size() > 0 && queue.peek().getLeft() <= currentDocId) { IntPair pair = queue.remove(); iteratorIsInQueue[pair.getRight()] = false; } currentDocId++; // Grab the next value from each iterator, if it's not in the queue for (int i = 0; i < docIdIterators.length; i++) { if (!iteratorIsInQueue[i]) { int nextDocId = docIdIterators[i].advance(currentDocId); if (nextDocId != Constants.EOF) { if (!(nextDocId <= maxDocId && nextDocId >= minDocId) && nextDocId >= currentDocId) { throw new RuntimeException( "next Doc : " + nextDocId + " should never crossing the range : [ " + minDocId + ", " + maxDocId + " ]"); } queue.add(new IntPair(nextDocId, i)); } iteratorIsInQueue[i] = true; } } if (queue.size() > 0) { currentDocId = queue.peek().getLeft(); } else { currentDocId = Constants.EOF; } long end = System.currentTimeMillis(); timeMeasure.addAndGet(end - start); // Remove this after tracing is added // if (currentDocId == Constants.EOF) { // LOGGER.debug("OR took:" + timeMeasure.get()); // } return currentDocId; }
public static void main(String[] args) { Scanner sc = new Scanner(System.in); int cases = sc.nextInt(), guests, i, j, c; long a, b; PriorityQueue<Long> beginTimes; PriorityQueue<Long> endTimes; // for each case for (c = 0; c < cases; c++) { // guests = sc.nextInt(); beginTimes = new PriorityQueue<Long>(); endTimes = new PriorityQueue<Long>(); for (i = 0; i < guests; i++) { a = sc.nextLong(); b = sc.nextLong(); beginTimes.add(a); endTimes.add(a + b); } int currentChairs = 0; long starting = 0; long ending = 0; int max = 0; long present = 0; boolean flag = true; while (!beginTimes.isEmpty() || !endTimes.isEmpty()) { if (!beginTimes.isEmpty() && beginTimes.peek() <= endTimes.peek()) { currentChairs++; if (currentChairs > max) max = currentChairs; present = beginTimes.poll(); starting = present; ending = present; } else { currentChairs--; present = endTimes.poll(); ending = present; } } System.out.println(max); } }
private boolean canExecute(long time) { QueueEntry entry = entries.peek(); if (entry == null) { return false; } else { return canExecute(entry, time); } }
void run() { Scanner sc = new Scanner(System.in); int N = sc.nextInt(), M = sc.nextInt(); PriorityQueue<R> q = new PriorityQueue<R>(); while (M-- != 0) q.add(new R(sc.nextInt(), sc.nextInt())); int res = 0, f = 0; while (!q.isEmpty() && f < N) { if (f + 1 < q.peek().s) break; int max = q.poll().t; while (!q.isEmpty() && q.peek().s <= f + 1) max = Math.max(max, q.poll().t); if (f < max) { res++; f = max; } } System.out.println(f == N ? res : "Impossible"); }
/*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; }